Class: Aws::Bedrock::Client

Inherits:
Seahorse::Client::Base
  • Object
show all
Includes:
ClientStubs
Defined in:
lib/aws-sdk-bedrock/client.rb

Overview

An API client for Bedrock. To construct a client, you need to configure a ‘:region` and `:credentials`.

client = Aws::Bedrock::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the [developer guide](/sdk-for-ruby/v3/developer-guide/setup-config.html).

See #initialize for a full list of supported configuration options.

Class Attribute Summary collapse

API Operations collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :plugins (Array<Seahorse::Client::Plugin>) — default: []] —

    A list of plugins to apply to the client. Each plugin is either a class name or an instance of a plugin class.

  • :credentials (required, Aws::CredentialProvider) —

    Your AWS credentials used for authentication. This can be any class that includes and implements ‘Aws::CredentialProvider`, or instance of any one of the following classes:

    • ‘Aws::Credentials` - Used for configuring static, non-refreshing credentials.

    • ‘Aws::SharedCredentials` - Used for loading static credentials from a shared file, such as `~/.aws/config`.

    • ‘Aws::AssumeRoleCredentials` - Used when you need to assume a role.

    • ‘Aws::AssumeRoleWebIdentityCredentials` - Used when you need to assume a role after providing credentials via the web.

    • ‘Aws::SSOCredentials` - Used for loading credentials from AWS SSO using an access token generated from `aws login`.

    • ‘Aws::ProcessCredentials` - Used for loading credentials from a process that outputs to stdout.

    • ‘Aws::InstanceProfileCredentials` - Used for loading credentials from an EC2 IMDS on an EC2 instance.

    • ‘Aws::ECSCredentials` - Used for loading credentials from instances running in ECS.

    • ‘Aws::CognitoIdentityCredentials` - Used for loading credentials from the Cognito Identity service.

    When ‘:credentials` are not configured directly, the following locations will be searched for credentials:

    • ‘Aws.config`

    • The ‘:access_key_id`, `:secret_access_key`, `:session_token`, and `:account_id` options.

    • ‘ENV`, `ENV`, `ENV`, and `ENV`.

    • ‘~/.aws/credentials`

    • ‘~/.aws/config`

    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of ‘Aws::InstanceProfileCredentials` or `Aws::ECSCredentials` to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting `ENV` to `true`.

  • :region (required, String) —

    The AWS region to connect to. The configured ‘:region` is used to determine the service `:endpoint`. When not passed, a default `:region` is searched for in the following locations:

  • :access_key_id (String)
  • :account_id (String)
  • :active_endpoint_cache (Boolean) — default: false —

    When set to ‘true`, a thread polling for endpoints will be running in the background every 60 secs (default). Defaults to `false`.

  • :adaptive_retry_wait_to_fill (Boolean) — default: true —

    Used only in ‘adaptive` retry mode. When true, the request will sleep until there is sufficent client side capacity to retry the request. When false, the request will raise a `RetryCapacityNotAvailableError` and will not retry instead of sleeping.

  • :auth_scheme_preference (Array<String>) —

    A list of preferred authentication schemes to use when making a request. Supported values are: ‘sigv4`, `sigv4a`, `httpBearerAuth`, and `noAuth`. When set using `ENV` or in shared config as `auth_scheme_preference`, the value should be a comma-separated list.

  • :client_side_monitoring (Boolean) — default: false —

    When ‘true`, client-side metrics will be collected for all API requests from this client.

  • :client_side_monitoring_client_id (String) — default: "" —

    Allows you to provide an identifier for this client which will be attached to all generated client side metrics. Defaults to an empty string.

  • :client_side_monitoring_host (String) — default: "127.0.0.1" —

    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_port (Integer) — default: 31000 —

    Required for publishing client metrics. The port that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher) — default: Aws::ClientSideMonitoring::Publisher —

    Allows you to provide a custom client-side monitoring publisher class. By default, will use the Client Side Monitoring Agent Publisher.

  • :convert_params (Boolean) — default: true —

    When ‘true`, an attempt is made to coerce request parameters into the required types.

  • :correct_clock_skew (Boolean) — default: true —

    Used only in ‘standard` and adaptive retry modes. Specifies whether to apply a clock skew correction and retry requests with skewed client clocks.

  • :defaults_mode (String) — default: "legacy" —

    See DefaultsModeConfiguration for a list of the accepted modes and the configuration defaults that are included.

  • :disable_host_prefix_injection (Boolean) — default: false —

    When ‘true`, the SDK will not prepend the modeled host prefix to the endpoint.

  • :disable_request_compression (Boolean) — default: false —

    When set to ‘true’ the request body will not be compressed for supported operations.

  • :endpoint (String, URI::HTTPS, URI::HTTP) —

    Normally you should not configure the ‘:endpoint` option directly. This is normally constructed from the `:region` option. Configuring `:endpoint` is normally reserved for connecting to test or custom endpoints. The endpoint should be a URI formatted like:

    'http://example.com'
'https://example.com'
'http://example.com:123'
  • :endpoint_cache_max_entries (Integer) — default: 1000 —

    Used for the maximum size limit of the LRU cache storing endpoints data for endpoint discovery enabled operations. Defaults to 1000.

  • :endpoint_cache_max_threads (Integer) — default: 10 —

    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

  • :endpoint_cache_poll_interval (Integer) — default: 60 —

    When :endpoint_discovery and :active_endpoint_cache is enabled, Use this option to config the time interval in seconds for making requests fetching endpoints information. Defaults to 60 sec.

  • :endpoint_discovery (Boolean) — default: false —

    When set to ‘true`, endpoint discovery will be enabled for operations when available.

  • :ignore_configured_endpoint_urls (Boolean) —

    Setting to true disables use of endpoint URLs provided via environment variables and the shared configuration file.

  • :log_formatter (Aws::Log::Formatter) — default: Aws::Log::Formatter.default —

    The log formatter.

  • :log_level (Symbol) — default: :info —

    The log level to send messages to the ‘:logger` at.

  • :logger (Logger) —

    The Logger instance to send log messages to. If this option is not set, logging will be disabled.

  • :max_attempts (Integer) — default: 3 —

    An integer representing the maximum number attempts that will be made for a single request, including the initial attempt. For example, setting this value to 5 will result in a request being retried up to 4 times. Used in ‘standard` and `adaptive` retry modes.

  • :profile (String) — default: "default" —

    Used when loading credentials from the shared credentials file at ‘HOME/.aws/credentials`. When not specified, ’default’ is used.

  • :request_checksum_calculation (String) — default: "when_supported" —

    Determines when a checksum will be calculated for request payloads. Values are:

    • ‘when_supported` - (default) When set, a checksum will be calculated for all request payloads of operations modeled with the `httpChecksum` trait where `requestChecksumRequired` is `true` and/or a `requestAlgorithmMember` is modeled.

    • ‘when_required` - When set, a checksum will only be calculated for request payloads of operations modeled with the `httpChecksum` trait where `requestChecksumRequired` is `true` or where a `requestAlgorithmMember` is modeled and supplied.

  • :request_min_compression_size_bytes (Integer) — default: 10240 —

    The minimum size in bytes that triggers compression for request bodies. The value must be non-negative integer value between 0 and 10485780 bytes inclusive.

  • :response_checksum_validation (String) — default: "when_supported" —

    Determines when checksum validation will be performed on response payloads. Values are:

    • ‘when_supported` - (default) When set, checksum validation is performed on all response payloads of operations modeled with the `httpChecksum` trait where `responseAlgorithms` is modeled, except when no modeled checksum algorithms are supported.

    • ‘when_required` - When set, checksum validation is not performed on response payloads of operations unless the checksum algorithm is supported and the `requestValidationModeMember` member is set to `ENABLED`.

  • :retry_backoff (Proc) —

    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay. This option is only used in the ‘legacy` retry mode.

  • :retry_base_delay (Float) — default: 0.3 —

    The base delay in seconds used by the default backoff function. This option is only used in the ‘legacy` retry mode.

  • :retry_jitter (Symbol) — default: :none —

    A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number. This option is only used in the ‘legacy` retry mode.

    @see www.awsarchitectureblog.com/2015/03/backoff.html

  • :retry_limit (Integer) — default: 3 —

    The maximum number of times to retry failed requests. Only ~ 500 level server errors and certain ~ 400 level client errors are retried. Generally, these are throttling errors, data checksum errors, networking errors, timeout errors, auth errors, endpoint discovery, and errors from expired credentials. This option is only used in the ‘legacy` retry mode.

  • :retry_max_delay (Integer) — default: 0 —

    The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function. This option is only used in the ‘legacy` retry mode.

  • :retry_mode (String) — default: "legacy" —

    Specifies which retry algorithm to use. Values are:

    • ‘legacy` - The pre-existing retry behavior. This is default value if no retry mode is provided.

    • ‘standard` - A standardized set of retry rules across the AWS SDKs. This includes support for retry quotas, which limit the number of unsuccessful retries a client can make.

    • ‘adaptive` - An experimental retry mode that includes all the functionality of `standard` mode along with automatic client side throttling. This is a provisional mode that may change behavior in the future.

  • :sdk_ua_app_id (String) —

    A unique and opaque application ID that is appended to the User-Agent header as app/sdk_ua_app_id. It should have a maximum length of 50. This variable is sourced from environment variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.

  • :secret_access_key (String)
  • :session_token (String)
  • :sigv4a_signing_region_set (Array) —

    A list of regions that should be signed with SigV4a signing. When not passed, a default ‘:sigv4a_signing_region_set` is searched for in the following locations:

  • :stub_responses (Boolean) — default: false —

    Causes the client to return stubbed responses. By default fake responses are generated and returned. You can specify the response data to return or errors to raise by calling ClientStubs#stub_responses. See ClientStubs for more information.

    ** Please note ** When response stubbing is enabled, no HTTP requests are made, and retries are disabled.

  • :telemetry_provider (Aws::Telemetry::TelemetryProviderBase) — default: Aws::Telemetry::NoOpTelemetryProvider —

    Allows you to provide a telemetry provider, which is used to emit telemetry data. By default, uses ‘NoOpTelemetryProvider` which will not record or emit any telemetry data. The SDK supports the following telemetry providers:

    • OpenTelemetry (OTel) - To use the OTel provider, install and require the

    ‘opentelemetry-sdk` gem and then, pass in an instance of a `Aws::Telemetry::OTelProvider` for telemetry provider.

  • :token_provider (Aws::TokenProvider) —

    Your Bearer token used for authentication. This can be any class that includes and implements ‘Aws::TokenProvider`, or instance of any one of the following classes:

    • ‘Aws::StaticTokenProvider` - Used for configuring static, non-refreshing tokens.

    • ‘Aws::SSOTokenProvider` - Used for loading tokens from AWS SSO using an access token generated from `aws login`.

    When ‘:token_provider` is not configured directly, the `Aws::TokenProviderChain` will be used to search for tokens configured for your profile in shared configuration files.

  • :use_dualstack_endpoint (Boolean) —

    When set to ‘true`, dualstack enabled endpoints (with `.aws` TLD) will be used if available.

  • :use_fips_endpoint (Boolean) —

    When set to ‘true`, fips compatible endpoints will be used if available. When a `fips` region is used, the region is normalized and this config is set to `true`.

  • :validate_params (Boolean) — default: true —

    When ‘true`, request parameters are validated before sending the request.

  • :endpoint_provider (Aws::Bedrock::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to ‘#resolve_endpoint(parameters)` where `parameters` is a Struct similar to `Aws::Bedrock::EndpointParameters`.

  • :http_continue_timeout (Float) — default: 1 —

    The number of seconds to wait for a 100-continue response before sending the request body. This option has no effect unless the request has “Expect” header set to “100-continue”. Defaults to ‘nil` which disables this behaviour. This value can safely be set per request on the session.

  • :http_idle_timeout (Float) — default: 5 —

    The number of seconds a connection is allowed to sit idle before it is considered stale. Stale connections are closed and removed from the pool before making a request.

  • :http_open_timeout (Float) — default: 15 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_proxy (URI::HTTP, String) —

    A proxy to send requests through. Formatted like ‘proxy.com:123’.

  • :http_read_timeout (Float) — default: 60 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_wire_trace (Boolean) — default: false —

    When ‘true`, HTTP debug output will be sent to the `:logger`.

  • :on_chunk_received (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the response body is received. It provides three arguments: the chunk, the number of bytes received, and the total number of bytes in the response (or nil if the server did not send a ‘content-length`).

  • :on_chunk_sent (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the request body is sent. It provides three arguments: the chunk, the number of bytes read from the body, and the total number of bytes in the body.

  • :raise_response_errors (Boolean) — default: true —

    When ‘true`, response errors are raised.

  • :ssl_ca_bundle (String) —

    Full path to the SSL certificate authority bundle file that should be used when verifying peer certificates. If you do not pass ‘:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.

  • :ssl_ca_directory (String) —

    Full path of the directory that contains the unbundled SSL certificate authority files for verifying peer certificates. If you do not pass ‘:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.

  • :ssl_ca_store (String) —

    Sets the X509::Store to verify peer certificate.

  • :ssl_cert (OpenSSL::X509::Certificate) —

    Sets a client certificate when creating http connections.

  • :ssl_key (OpenSSL::PKey) —

    Sets a client key when creating http connections.

  • :ssl_timeout (Float) —

    Sets the SSL timeout in seconds

  • :ssl_verify_peer (Boolean) — default: true —

    When ‘true`, SSL peer certificates are verified when establishing a connection.



475
476
477
 
# File 'lib/aws-sdk-bedrock/client.rb', line 475

def initialize(*args)
  super
end

Class Attribute Details

.identifier ⇒ Object (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



8262
8263
8264
 
# File 'lib/aws-sdk-bedrock/client.rb', line 8262

def identifier
  @identifier
end

Class Method Details

.errors_module ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



8265
8266
8267
 
# File 'lib/aws-sdk-bedrock/client.rb', line 8265

def errors_module
  Errors
end

Instance Method Details

#batch_delete_advanced_prompt_optimization_job(params = {}) ⇒ Types::BatchDeleteAdvancedPromptOptimizationJobResponse

Batch delete the specified advanced prompt optimization jobs.

Examples:

Request syntax with placeholder values


resp = client.batch_delete_advanced_prompt_optimization_job({
  job_identifiers: ["AdvancedPromptOptimizationJobIdentifier"], # required
})

Response structure


resp.errors #=> Array
resp.errors[0].job_identifier #=> String
resp.errors[0].code #=> String
resp.errors[0].message #=> String
resp.advanced_prompt_optimization_jobs #=> Array
resp.advanced_prompt_optimization_jobs[0].job_identifier #=> String
resp.advanced_prompt_optimization_jobs[0].job_status #=> String, one of "InProgress", "Completed", "Failed", "PartiallyCompleted", "Stopping", "Stopped", "Deleting"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifiers (required, Array<String>) —

    List of advanced prompt optimization job identifiers to delete.

Returns:

See Also:



511
512
513
514
 
# File 'lib/aws-sdk-bedrock/client.rb', line 511

def batch_delete_advanced_prompt_optimization_job(params = {}, options = {})
  req = build_request(:batch_delete_advanced_prompt_optimization_job, params)
  req.send_request(options)
end

#batch_delete_evaluation_job(params = {}) ⇒ Types::BatchDeleteEvaluationJobResponse

Deletes a batch of evaluation jobs. An evaluation job can only be deleted if it has following status ‘FAILED`, `COMPLETED`, and `STOPPED`. You can request up to 25 model evaluation jobs be deleted in a single request.

Examples:

Example: Delete evaluation jobs


# The following example shows a request to delete two model evaluation jobs, where one of the jobs is not found.

resp = client.batch_delete_evaluation_job({
  job_identifiers: [
    "arn:aws:bedrock:us-east-2:123456789012:evaluation-job/12rnxmplqv0v", 
    "arn:aws:bedrock:us-east-2:123456789012:evaluation-job/rispxmpl12rn", 
  ], 
})

resp.to_h outputs the following:
{
  errors: [
    {
      code: "404", 
      job_identifier: "arn:aws:bedrock:us-east-2:123456789012:evaluation-job/rispxmpl12rn", 
      message: "Unable to locate this job to delete.", 
    }, 
  ], 
  evaluation_jobs: [
    {
      job_identifier: "arn:aws:bedrock:us-east-2:123456789012:evaluation-job/12rnxmplqv0v", 
      job_status: "Deleting", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.batch_delete_evaluation_job({
  job_identifiers: ["EvaluationJobIdentifier"], # required
})

Response structure


resp.errors #=> Array
resp.errors[0].job_identifier #=> String
resp.errors[0].code #=> String
resp.errors[0].message #=> String
resp.evaluation_jobs #=> Array
resp.evaluation_jobs[0].job_identifier #=> String
resp.evaluation_jobs[0].job_status #=> String, one of "InProgress", "Completed", "Failed", "Stopping", "Stopped", "Deleting"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifiers (required, Array<String>) —

    A list of one or more evaluation job Amazon Resource Names (ARNs) you want to delete.

Returns:

See Also:



579
580
581
582
 
# File 'lib/aws-sdk-bedrock/client.rb', line 579

def batch_delete_evaluation_job(params = {}, options = {})
  req = build_request(:batch_delete_evaluation_job, params)
  req.send_request(options)
end

#build_request(operation_name, params = {}) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • params ({}) (defaults to: {}) 


8235
8236
8237
8238
8239
8240
8241
8242
8243
8244
8245
8246
8247
8248
8249
8250
8251
 
# File 'lib/aws-sdk-bedrock/client.rb', line 8235

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  tracer = config.telemetry_provider.tracer_provider.tracer(
    Aws::Telemetry.module_to_tracer_name('Aws::Bedrock')
  )
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config,
    tracer: tracer
  )
  context[:gem_name] = 'aws-sdk-bedrock'
  context[:gem_version] = '1.83.0'
  Seahorse::Client::Request.new(handlers, context)
end

#cancel_automated_reasoning_policy_build_workflow(params = {}) ⇒ Struct

Cancels a running Automated Reasoning policy build workflow. This stops the policy generation process and prevents further processing of the source documents.

Examples:

Request syntax with placeholder values


resp = client.cancel_automated_reasoning_policy_build_workflow({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy whose build workflow you want to cancel.

  • :build_workflow_id (required, String) —

    The unique identifier of the build workflow to cancel. You can get this ID from the StartAutomatedReasoningPolicyBuildWorkflow response or by listing build workflows.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



610
611
612
613
 
# File 'lib/aws-sdk-bedrock/client.rb', line 610

def cancel_automated_reasoning_policy_build_workflow(params = {}, options = {})
  req = build_request(:cancel_automated_reasoning_policy_build_workflow, params)
  req.send_request(options)
end

#create_advanced_prompt_optimization_job(params = {}) ⇒ Types::CreateAdvancedPromptOptimizationJobResponse

Creates an asynchronous batch job for advanced prompt optimization.

Examples:

Request syntax with placeholder values


resp = client.create_advanced_prompt_optimization_job({
  job_name: "AdvancedPromptOptimizationJobName", # required
  job_description: "AdvancedPromptOptimizationJobDescription",
  client_token: "IdempotencyToken",
  input_config: { # required
    s3_uri: "S3Uri", # required
  },
  output_config: { # required
    s3_uri: "S3UriFolder", # required
  },
  encryption_key_arn: "KmsKeyArn",
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  model_configurations: [ # required
    {
      model_id: "BedrockModelId", # required
      inference_config: {
        max_tokens: 1,
        temperature: 1.0,
        top_p: 1.0,
        stop_sequences: ["InferenceConfigurationStopSequencesListMemberString"],
      },
      additional_model_request_fields: {
        "AdditionalModelRequestFieldsKey" => {
        },
      },
    },
  ],
})

Response structure


resp.job_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_name (required, String) —

    Name of the advanced prompt optimization job.

  • :job_description (String) —

    Description of the advanced prompt optimization job.

  • :client_token (String) —

    Idempotency token for the request.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :input_config (required, Types::AdvancedPromptOptimizationInputConfig) —

    Input data configuration for the advanced prompt optimization job.

  • :output_config (required, Types::AdvancedPromptOptimizationOutputConfig) —

    Output data configuration for the advanced prompt optimization job.

  • :encryption_key_arn (String) —

    KMS key ARN for encrypting output data.

  • :tags (Array<Types::Tag>) —

    Tags to associate with the job.

  • :model_configurations (required, Array<Types::ModelConfiguration>) —

    Model configurations for advanced prompt optimization.

Returns:

See Also:



692
693
694
695
 
# File 'lib/aws-sdk-bedrock/client.rb', line 692

def create_advanced_prompt_optimization_job(params = {}, options = {})
  req = build_request(:create_advanced_prompt_optimization_job, params)
  req.send_request(options)
end

#create_automated_reasoning_policy(params = {}) ⇒ Types::CreateAutomatedReasoningPolicyResponse

Creates an Automated Reasoning policy for Amazon Bedrock Guardrails. Automated Reasoning policies use mathematical techniques to detect hallucinations, suggest corrections, and highlight unstated assumptions in the responses of your GenAI application.

To create a policy, you upload a source document that describes the rules that you’re encoding. Automated Reasoning extracts important concepts from the source document that will become variables in the policy and infers policy rules.

Examples:

Request syntax with placeholder values


resp = client.create_automated_reasoning_policy({
  name: "AutomatedReasoningPolicyName", # required
  description: "AutomatedReasoningPolicyDescription",
  client_request_token: "IdempotencyToken",
  policy_definition: {
    version: "AutomatedReasoningPolicyFormatVersion",
    types: [
      {
        name: "AutomatedReasoningPolicyDefinitionTypeName", # required
        description: "AutomatedReasoningPolicyDefinitionTypeDescription",
        values: [ # required
          {
            value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
            description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
          },
        ],
      },
    ],
    rules: [
      {
        id: "AutomatedReasoningPolicyDefinitionRuleId", # required
        expression: "AutomatedReasoningPolicyDefinitionRuleExpression", # required
        alternate_expression: "AutomatedReasoningPolicyDefinitionRuleAlternateExpression",
      },
    ],
    variables: [
      {
        name: "AutomatedReasoningPolicyDefinitionVariableName", # required
        type: "AutomatedReasoningPolicyDefinitionTypeName", # required
        description: "AutomatedReasoningPolicyDefinitionVariableDescription", # required
      },
    ],
  },
  kms_key_id: "KmsKeyId",
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure


resp.policy_arn #=> String
resp.version #=> String
resp.name #=> String
resp.description #=> String
resp.definition_hash #=> String
resp.created_at #=> Time
resp.updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :name (required, String) —

    A unique name for the Automated Reasoning policy. The name must be between 1 and 63 characters and can contain letters, numbers, hyphens, and underscores.

  • :description (String) —

    A description of the Automated Reasoning policy. Use this to provide context about the policy’s purpose and the types of validations it performs.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the operation completes no more than once. If this token matches a previous request, Amazon Bedrock ignores the request but doesn’t return an error.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :policy_definition (Types::AutomatedReasoningPolicyDefinition) —

    The policy definition that contains the formal logic rules, variables, and custom variable types used to validate foundation model responses in your application.

  • :kms_key_id (String) —

    The identifier of the KMS key to use for encrypting the automated reasoning policy and its associated artifacts. If you don’t specify a KMS key, Amazon Bedrock uses an KMS managed key for encryption. For enhanced security and control, you can specify a customer managed KMS key.

  • :tags (Array<Types::Tag>) —

    A list of tags to associate with the Automated Reasoning policy. Tags help you organize and manage your policies.

Returns:

See Also:



809
810
811
812
 
# File 'lib/aws-sdk-bedrock/client.rb', line 809

def create_automated_reasoning_policy(params = {}, options = {})
  req = build_request(:create_automated_reasoning_policy, params)
  req.send_request(options)
end

#create_automated_reasoning_policy_test_case(params = {}) ⇒ Types::CreateAutomatedReasoningPolicyTestCaseResponse

Creates a test for an Automated Reasoning policy. Tests validate that your policy works as expected by providing sample inputs and expected outcomes. Use tests to verify policy behavior before deploying to production.

Examples:

Request syntax with placeholder values


resp = client.create_automated_reasoning_policy_test_case({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  guard_content: "AutomatedReasoningPolicyTestGuardContent", # required
  query_content: "AutomatedReasoningPolicyTestQueryContent",
  expected_aggregated_findings_result: "VALID", # required, accepts VALID, INVALID, SATISFIABLE, IMPOSSIBLE, TRANSLATION_AMBIGUOUS, TOO_COMPLEX, NO_TRANSLATION
  client_request_token: "IdempotencyToken",
  confidence_threshold: 1.0,
})

Response structure


resp.policy_arn #=> String
resp.test_case_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy for which to create the test.

  • :guard_content (required, String) —

    The output content that’s validated by the Automated Reasoning policy. This represents the foundation model response that will be checked for accuracy.

  • :query_content (String) —

    The input query or prompt that generated the content. This provides context for the validation.

  • :expected_aggregated_findings_result (required, String) —

    The expected result of the Automated Reasoning check. Valid values include: , TOO_COMPLEX, and NO_TRANSLATIONS.

    • ‘VALID` - The claims are true. The claims are implied by the premises and the Automated Reasoning policy. Given the Automated Reasoning policy and premises, it is not possible for these claims to be false. In other words, there are no alternative answers that are true that contradict the claims.

    • ‘INVALID` - The claims are false. The claims are not implied by the premises and Automated Reasoning policy. Furthermore, there exists different claims that are consistent with the premises and Automated Reasoning policy.

    • ‘SATISFIABLE` - The claims can be true or false. It depends on what assumptions are made for the claim to be implied from the premises and Automated Reasoning policy rules. In this situation, different assumptions can make input claims false and alternative claims true.

    • ‘IMPOSSIBLE` - Automated Reasoning can’t make a statement about the claims. This can happen if the premises are logically incorrect, or if there is a conflict within the Automated Reasoning policy itself.

    • ‘TRANSLATION_AMBIGUOUS` - Detected an ambiguity in the translation meant it would be unsound to continue with validity checking. Additional context or follow-up questions might be needed to get translation to succeed.

    • ‘TOO_COMPLEX` - The input contains too much information for Automated Reasoning to process within its latency limits.

    • ‘NO_TRANSLATIONS` - Identifies that some or all of the input prompt wasn’t translated into logic. This can happen if the input isn’t relevant to the Automated Reasoning policy, or if the policy doesn’t have variables to model relevant input. If Automated Reasoning can’t translate anything, you get a single ‘NO_TRANSLATIONS` finding. You might also see a `NO_TRANSLATIONS` (along with other findings) if some part of the validation isn’t translated.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :confidence_threshold (Float) —

    The minimum confidence level for logic validation. Content that meets the threshold is considered a high-confidence finding that can be validated.

Returns:

See Also:



912
913
914
915
 
# File 'lib/aws-sdk-bedrock/client.rb', line 912

def create_automated_reasoning_policy_test_case(params = {}, options = {})
  req = build_request(:create_automated_reasoning_policy_test_case, params)
  req.send_request(options)
end

#create_automated_reasoning_policy_version(params = {}) ⇒ Types::CreateAutomatedReasoningPolicyVersionResponse

Creates a new version of an existing Automated Reasoning policy. This allows you to iterate on your policy rules while maintaining previous versions for rollback or comparison purposes.

Examples:

Request syntax with placeholder values


resp = client.create_automated_reasoning_policy_version({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  client_request_token: "IdempotencyToken",
  last_updated_definition_hash: "AutomatedReasoningPolicyHash", # required
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure


resp.policy_arn #=> String
resp.version #=> String
resp.name #=> String
resp.description #=> String
resp.definition_hash #=> String
resp.created_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy for which to create a version.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :last_updated_definition_hash (required, String) —

    The hash of the current policy definition used as a concurrency token to ensure the policy hasn’t been modified since you last retrieved it.

  • :tags (Array<Types::Tag>) —

    A list of tags to associate with the policy version.

Returns:

See Also:



978
979
980
981
 
# File 'lib/aws-sdk-bedrock/client.rb', line 978

def create_automated_reasoning_policy_version(params = {}, options = {})
  req = build_request(:create_automated_reasoning_policy_version, params)
  req.send_request(options)
end

#create_custom_model(params = {}) ⇒ Types::CreateCustomModelResponse

Creates a new custom model in Amazon Bedrock. After the model is active, you can use it for inference.

To use the model for inference, you must purchase Provisioned Throughput for it. You can’t use On-demand inference with these custom models. For more information about Provisioned Throughput, see [Provisioned Throughput].

The model appears in ‘ListCustomModels` with a `customizationType` of `imported`. To track the status of the new model, you use the `GetCustomModel` API operation. The model can be in the following states:

  • ‘Creating` - Initial state during validation and registration

  • ‘Active` - Model is ready for use in inference

  • ‘Failed` - Creation process encountered an error

**Related APIs**

  • GetCustomModel][2
  • ListCustomModels][3
  • DeleteCustomModel][4

[1]: docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html [2]: docs.aws.amazon.com/bedrock/latest/APIReference/API_GetCustomModel.html [3]: docs.aws.amazon.com/bedrock/latest/APIReference/API_ListCustomModels.html [4]: docs.aws.amazon.com/bedrock/latest/APIReference/API_DeleteCustomModel.html

Examples:

Example: Successful CreateCustomModel API call


resp = client.create_custom_model({
  client_request_token: "foo", 
  model_kms_key_arn: "arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab", 
  model_name: "SampleModel", 
  model_source_config: {
    s3_data_source: {
      s3_uri: "s3://my-bucket/folder", 
    }, 
  }, 
  model_tags: [
    {
      key: "foo", 
      value: "foo", 
    }, 
    {
      key: "foo", 
      value: "foo", 
    }, 
  ], 
  role_arn: "arn:aws:iam::123456789012:role/SampleRole", 
})

resp.to_h outputs the following:
{
  model_arn: "arn:aws:bedrock:us-east-1:123456789012:custom-model/imported/abcdef123456", 
}

Request syntax with placeholder values


resp = client.create_custom_model({
  model_name: "CustomModelName", # required
  model_source_config: { # required
    s3_data_source: {
      s3_uri: "S3Uri", # required
    },
  },
  model_kms_key_arn: "KmsKeyArn",
  role_arn: "RoleArn",
  model_tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  client_request_token: "IdempotencyToken",
})

Response structure


resp.model_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_name (required, String) —

    A unique name for the custom model.

  • :model_source_config (required, Types::ModelDataSource) —

    The data source for the model. The Amazon S3 URI in the model source must be for the Amazon-managed Amazon S3 bucket containing your model artifacts.

  • :model_kms_key_arn (String) —

    The Amazon Resource Name (ARN) of the customer managed KMS key to encrypt the custom model. If you don’t provide a KMS key, Amazon Bedrock uses an Amazon Web Services-managed KMS key to encrypt the model.

    If you provide a customer managed KMS key, your Amazon Bedrock service role must have permissions to use it. For more information see [Encryption of imported models].

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/encryption-import-model.html

  • :role_arn (String) —

    The Amazon Resource Name (ARN) of an IAM service role that Amazon Bedrock assumes to perform tasks on your behalf. This role must have permissions to access the Amazon S3 bucket containing your model artifacts and the KMS key (if specified). For more information, see

    Setting up an IAM service role for importing models][1

    in the Amazon

    Bedrock User Guide.

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/model-import-iam-role.html

  • :model_tags (Array<Types::Tag>) —

    A list of key-value pairs to associate with the custom model resource. You can use these tags to organize and identify your resources.

    For more information, see [Tagging resources] in the [Amazon Bedrock User Guide].

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/tagging.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. For more information, see [Ensuring idempotency].

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

    [1]: docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html

Returns:

See Also:



1138
1139
1140
1141
 
# File 'lib/aws-sdk-bedrock/client.rb', line 1138

def create_custom_model(params = {}, options = {})
  req = build_request(:create_custom_model, params)
  req.send_request(options)
end

#create_custom_model_deployment(params = {}) ⇒ Types::CreateCustomModelDeploymentResponse

Deploys a custom model for on-demand inference in Amazon Bedrock. After you deploy your custom model, you use the deployment’s Amazon Resource Name (ARN) as the ‘modelId` parameter when you submit prompts and generate responses with model inference.

For more information about setting up on-demand inference for custom models, see [Set up inference for a custom model].

The following actions are related to the ‘CreateCustomModelDeployment` operation:

  • GetCustomModelDeployment][2
  • ListCustomModelDeployments][3
  • DeleteCustomModelDeployment][4

[1]: docs.aws.amazon.com/bedrock/latest/userguide/model-customization-use.html [2]: docs.aws.amazon.com/bedrock/latest/APIReference/API_GetCustomModelDeployment.html [3]: docs.aws.amazon.com/bedrock/latest/APIReference/API_ListCustomModelDeployments.html [4]: docs.aws.amazon.com/bedrock/latest/APIReference/API_DeleteCustomModelDeployment.html

Examples:

Request syntax with placeholder values


resp = client.create_custom_model_deployment({
  model_deployment_name: "ModelDeploymentName", # required
  model_arn: "CustomModelArn", # required
  description: "CustomModelDeploymentDescription",
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  client_request_token: "IdempotencyToken",
})

Response structure


resp.custom_model_deployment_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_deployment_name (required, String) —

    The name for the custom model deployment. The name must be unique within your Amazon Web Services account and Region.

  • :model_arn (required, String) —

    The Amazon Resource Name (ARN) of the custom model to deploy for on-demand inference. The custom model must be in the ‘Active` state.

  • :description (String) —

    A description for the custom model deployment to help you identify its purpose.

  • :tags (Array<Types::Tag>) —

    Tags to assign to the custom model deployment. You can use tags to organize and track your Amazon Web Services resources for cost allocation and management purposes.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. For more information, see [Ensuring idempotency].

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/model-customization-idempotency.html

Returns:

See Also:



1224
1225
1226
1227
 
# File 'lib/aws-sdk-bedrock/client.rb', line 1224

def create_custom_model_deployment(params = {}, options = {})
  req = build_request(:create_custom_model_deployment, params)
  req.send_request(options)
end

#create_evaluation_job(params = {}) ⇒ Types::CreateEvaluationJobResponse

Creates an evaluation job.

Examples:

Request syntax with placeholder values


resp = client.create_evaluation_job({
  job_name: "EvaluationJobName", # required
  job_description: "EvaluationJobDescription",
  client_request_token: "IdempotencyToken",
  role_arn: "RoleArn", # required
  customer_encryption_key_id: "KmsKeyId",
  job_tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  application_type: "ModelEvaluation", # accepts ModelEvaluation, RagEvaluation
  evaluation_config: { # required
    automated: {
      dataset_metric_configs: [ # required
        {
          task_type: "Summarization", # required, accepts Summarization, Classification, QuestionAndAnswer, Generation, Custom
          dataset: { # required
            name: "EvaluationDatasetName", # required
            dataset_location: {
              s3_uri: "S3Uri",
            },
          },
          metric_names: ["EvaluationMetricName"], # required
        },
      ],
      evaluator_model_config: {
        bedrock_evaluator_models: [
          {
            model_identifier: "EvaluatorModelIdentifier", # required
          },
        ],
      },
      custom_metric_config: {
        custom_metrics: [ # required
          {
            custom_metric_definition: {
              name: "MetricName", # required
              instructions: "CustomMetricInstructions", # required
              rating_scale: [
                {
                  definition: "RatingScaleItemDefinition", # required
                  value: { # required
                    string_value: "RatingScaleItemValueStringValueString",
                    float_value: 1.0,
                  },
                },
              ],
            },
          },
        ],
        evaluator_model_config: { # required
          bedrock_evaluator_models: [ # required
            {
              model_identifier: "EvaluatorModelIdentifier", # required
            },
          ],
        },
      },
    },
    human: {
      human_workflow_config: {
        flow_definition_arn: "SageMakerFlowDefinitionArn", # required
        instructions: "HumanTaskInstructions",
      },
      custom_metrics: [
        {
          name: "EvaluationMetricName", # required
          description: "EvaluationMetricDescription",
          rating_method: "EvaluationRatingMethod", # required
        },
      ],
      dataset_metric_configs: [ # required
        {
          task_type: "Summarization", # required, accepts Summarization, Classification, QuestionAndAnswer, Generation, Custom
          dataset: { # required
            name: "EvaluationDatasetName", # required
            dataset_location: {
              s3_uri: "S3Uri",
            },
          },
          metric_names: ["EvaluationMetricName"], # required
        },
      ],
    },
  },
  inference_config: { # required
    models: [
      {
        bedrock_model: {
          model_identifier: "EvaluationBedrockModelIdentifier", # required
          inference_params: "EvaluationModelInferenceParams",
          performance_config: {
            latency: "standard", # accepts standard, optimized
          },
        },
        precomputed_inference_source: {
          inference_source_identifier: "EvaluationPrecomputedInferenceSourceIdentifier", # required
        },
      },
    ],
    rag_configs: [
      {
        knowledge_base_config: {
          retrieve_config: {
            knowledge_base_id: "KnowledgeBaseId", # required
            knowledge_base_retrieval_configuration: { # required
              vector_search_configuration: { # required
                number_of_results: 1,
                override_search_type: "HYBRID", # accepts HYBRID, SEMANTIC
                filter: {
                  equals: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  not_equals: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  greater_than: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  greater_than_or_equals: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  less_than: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  less_than_or_equals: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  in: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  not_in: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  starts_with: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  list_contains: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  string_contains: {
                    key: "FilterKey", # required
                    value: { # required
                    },
                  },
                  and_all: [
                    {
                      # recursive RetrievalFilter
                    },
                  ],
                  or_all: [
                    {
                      # recursive RetrievalFilter
                    },
                  ],
                },
                implicit_filter_configuration: {
                  metadata_attributes: [ # required
                    {
                      key: "MetadataAttributeSchemaKeyString", # required
                      type: "STRING", # required, accepts STRING, NUMBER, BOOLEAN, STRING_LIST
                      description: "MetadataAttributeSchemaDescriptionString", # required
                    },
                  ],
                  model_arn: "BedrockModelArn", # required
                },
                reranking_configuration: {
                  type: "BEDROCK_RERANKING_MODEL", # required, accepts BEDROCK_RERANKING_MODEL
                  bedrock_reranking_configuration: {
                    model_configuration: { # required
                      model_arn: "BedrockRerankingModelArn", # required
                      additional_model_request_fields: {
                        "AdditionalModelRequestFieldsKey" => {
                        },
                      },
                    },
                    number_of_reranked_results: 1,
                    metadata_configuration: {
                      selection_mode: "SELECTIVE", # required, accepts SELECTIVE, ALL
                      selective_mode_configuration: {
                        fields_to_include: [
                          {
                            field_name: "FieldForRerankingFieldNameString", # required
                          },
                        ],
                        fields_to_exclude: [
                          {
                            field_name: "FieldForRerankingFieldNameString", # required
                          },
                        ],
                      },
                    },
                  },
                },
              },
            },
          },
          retrieve_and_generate_config: {
            type: "KNOWLEDGE_BASE", # required, accepts KNOWLEDGE_BASE, EXTERNAL_SOURCES
            knowledge_base_configuration: {
              knowledge_base_id: "KnowledgeBaseId", # required
              model_arn: "BedrockModelArn", # required
              retrieval_configuration: {
                vector_search_configuration: { # required
                  number_of_results: 1,
                  override_search_type: "HYBRID", # accepts HYBRID, SEMANTIC
                  filter: {
                    equals: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    not_equals: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    greater_than: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    greater_than_or_equals: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    less_than: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    less_than_or_equals: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    in: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    not_in: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    starts_with: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    list_contains: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    string_contains: {
                      key: "FilterKey", # required
                      value: { # required
                      },
                    },
                    and_all: [
                      {
                        # recursive RetrievalFilter
                      },
                    ],
                    or_all: [
                      {
                        # recursive RetrievalFilter
                      },
                    ],
                  },
                  implicit_filter_configuration: {
                    metadata_attributes: [ # required
                      {
                        key: "MetadataAttributeSchemaKeyString", # required
                        type: "STRING", # required, accepts STRING, NUMBER, BOOLEAN, STRING_LIST
                        description: "MetadataAttributeSchemaDescriptionString", # required
                      },
                    ],
                    model_arn: "BedrockModelArn", # required
                  },
                  reranking_configuration: {
                    type: "BEDROCK_RERANKING_MODEL", # required, accepts BEDROCK_RERANKING_MODEL
                    bedrock_reranking_configuration: {
                      model_configuration: { # required
                        model_arn: "BedrockRerankingModelArn", # required
                        additional_model_request_fields: {
                          "AdditionalModelRequestFieldsKey" => {
                          },
                        },
                      },
                      number_of_reranked_results: 1,
                      metadata_configuration: {
                        selection_mode: "SELECTIVE", # required, accepts SELECTIVE, ALL
                        selective_mode_configuration: {
                          fields_to_include: [
                            {
                              field_name: "FieldForRerankingFieldNameString", # required
                            },
                          ],
                          fields_to_exclude: [
                            {
                              field_name: "FieldForRerankingFieldNameString", # required
                            },
                          ],
                        },
                      },
                    },
                  },
                },
              },
              generation_configuration: {
                prompt_template: {
                  text_prompt_template: "TextPromptTemplate",
                },
                guardrail_configuration: {
                  guardrail_id: "GuardrailConfigurationGuardrailIdString", # required
                  guardrail_version: "GuardrailConfigurationGuardrailVersionString", # required
                },
                kb_inference_config: {
                  text_inference_config: {
                    temperature: 1.0,
                    top_p: 1.0,
                    max_tokens: 1,
                    stop_sequences: ["RAGStopSequencesMemberString"],
                  },
                },
                additional_model_request_fields: {
                  "AdditionalModelRequestFieldsKey" => {
                  },
                },
              },
              orchestration_configuration: {
                query_transformation_configuration: { # required
                  type: "QUERY_DECOMPOSITION", # required, accepts QUERY_DECOMPOSITION
                },
              },
            },
            external_sources_configuration: {
              model_arn: "BedrockModelArn", # required
              sources: [ # required
                {
                  source_type: "S3", # required, accepts S3, BYTE_CONTENT
                  s3_location: {
                    uri: "kBS3Uri", # required
                  },
                  byte_content: {
                    identifier: "Identifier", # required
                    content_type: "ContentType", # required
                    data: "data", # required
                  },
                },
              ],
              generation_configuration: {
                prompt_template: {
                  text_prompt_template: "TextPromptTemplate",
                },
                guardrail_configuration: {
                  guardrail_id: "GuardrailConfigurationGuardrailIdString", # required
                  guardrail_version: "GuardrailConfigurationGuardrailVersionString", # required
                },
                kb_inference_config: {
                  text_inference_config: {
                    temperature: 1.0,
                    top_p: 1.0,
                    max_tokens: 1,
                    stop_sequences: ["RAGStopSequencesMemberString"],
                  },
                },
                additional_model_request_fields: {
                  "AdditionalModelRequestFieldsKey" => {
                  },
                },
              },
            },
          },
        },
        precomputed_rag_source_config: {
          retrieve_source_config: {
            rag_source_identifier: "EvaluationPrecomputedRagSourceIdentifier", # required
          },
          retrieve_and_generate_source_config: {
            rag_source_identifier: "EvaluationPrecomputedRagSourceIdentifier", # required
          },
        },
      },
    ],
  },
  output_data_config: { # required
    s3_uri: "S3Uri", # required
  },
})

Response structure


resp.job_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_name (required, String) —

    A name for the evaluation job. Names must unique with your Amazon Web Services account, and your account’s Amazon Web Services region.

  • :job_description (String) —

    A description of the evaluation job.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. For more information, see [Ensuring idempotency].

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

    [1]: docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html

  • :role_arn (required, String) —

    The Amazon Resource Name (ARN) of an IAM service role that Amazon Bedrock can assume to perform tasks on your behalf. To learn more about the required permissions, see [Required permissions for model evaluations].

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/model-evaluation-security.html

  • :customer_encryption_key_id (String) —

    Specify your customer managed encryption key Amazon Resource Name (ARN) that will be used to encrypt your evaluation job.

  • :job_tags (Array<Types::Tag>) —

    Tags to attach to the model evaluation job.

  • :application_type (String) —

    Specifies whether the evaluation job is for evaluating a model or evaluating a knowledge base (retrieval and response generation).

  • :evaluation_config (required, Types::EvaluationConfig) —

    Contains the configuration details of either an automated or human-based evaluation job.

  • :inference_config (required, Types::EvaluationInferenceConfig) —

    Contains the configuration details of the inference model for the evaluation job.

    For model evaluation jobs, automated jobs support a single model or [inference profile], and jobs that use human workers support two models or inference profiles.

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html

  • :output_data_config (required, Types::EvaluationOutputDataConfig) —

    Contains the configuration details of the Amazon S3 bucket for storing the results of the evaluation job.

Returns:

See Also:



1723
1724
1725
1726
 
# File 'lib/aws-sdk-bedrock/client.rb', line 1723

def create_evaluation_job(params = {}, options = {})
  req = build_request(:create_evaluation_job, params)
  req.send_request(options)
end

#create_foundation_model_agreement(params = {}) ⇒ Types::CreateFoundationModelAgreementResponse

Request a model access agreement for the specified model.

Examples:

Request syntax with placeholder values


resp = client.create_foundation_model_agreement({
  offer_token: "OfferToken", # required
  model_id: "BedrockModelId", # required
})

Response structure


resp.model_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :offer_token (required, String) —

    An offer token encapsulates the information for an offer.

  • :model_id (required, String) —

    Model Id of the model for the access request.

Returns:

See Also:



1755
1756
1757
1758
 
# File 'lib/aws-sdk-bedrock/client.rb', line 1755

def create_foundation_model_agreement(params = {}, options = {})
  req = build_request(:create_foundation_model_agreement, params)
  req.send_request(options)
end

#create_guardrail(params = {}) ⇒ Types::CreateGuardrailResponse

Creates a guardrail to block topics and to implement safeguards for your generative AI applications.

You can configure the following policies in a guardrail to avoid undesirable and harmful content, filter out denied topics and words, and remove sensitive information for privacy protection.

  • **Content filters** - Adjust filter strengths to block input prompts or model responses containing harmful content.

  • **Denied topics** - Define a set of topics that are undesirable in the context of your application. These topics will be blocked if detected in user queries or model responses.

  • **Word filters** - Configure filters to block undesirable words, phrases, and profanity. Such words can include offensive terms, competitor names etc.

  • **Sensitive information filters** - Block or mask sensitive information such as personally identifiable information (PII) or custom regex in user inputs and model responses.

In addition to the above policies, you can also configure the messages to be returned to the user if a user input or model response is in violation of the policies defined in the guardrail.

For more information, see [Amazon Bedrock Guardrails] in the *Amazon Bedrock User Guide*.

[1]: docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html

Examples:

Request syntax with placeholder values


resp = client.create_guardrail({
  name: "GuardrailName", # required
  description: "GuardrailDescription",
  topic_policy_config: {
    topics_config: [ # required
      {
        name: "GuardrailTopicName", # required
        definition: "GuardrailTopicDefinition", # required
        examples: ["GuardrailTopicExample"],
        type: "DENY", # required, accepts DENY
        input_action: "BLOCK", # accepts BLOCK, NONE
        output_action: "BLOCK", # accepts BLOCK, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
    tier_config: {
      tier_name: "CLASSIC", # required, accepts CLASSIC, STANDARD
    },
  },
  content_policy_config: {
    filters_config: [ # required
      {
        type: "SEXUAL", # required, accepts SEXUAL, VIOLENCE, HATE, INSULTS, MISCONDUCT, PROMPT_ATTACK
        input_strength: "NONE", # required, accepts NONE, LOW, MEDIUM, HIGH
        output_strength: "NONE", # required, accepts NONE, LOW, MEDIUM, HIGH
        input_modalities: ["TEXT"], # accepts TEXT, IMAGE
        output_modalities: ["TEXT"], # accepts TEXT, IMAGE
        input_action: "BLOCK", # accepts BLOCK, NONE
        output_action: "BLOCK", # accepts BLOCK, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
    tier_config: {
      tier_name: "CLASSIC", # required, accepts CLASSIC, STANDARD
    },
  },
  word_policy_config: {
    words_config: [
      {
        text: "GuardrailWordConfigTextString", # required
        input_action: "BLOCK", # accepts BLOCK, NONE
        output_action: "BLOCK", # accepts BLOCK, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
    managed_word_lists_config: [
      {
        type: "PROFANITY", # required, accepts PROFANITY
        input_action: "BLOCK", # accepts BLOCK, NONE
        output_action: "BLOCK", # accepts BLOCK, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
  },
  sensitive_information_policy_config: {
    pii_entities_config: [
      {
        type: "ADDRESS", # required, accepts ADDRESS, AGE, AWS_ACCESS_KEY, AWS_SECRET_KEY, CA_HEALTH_NUMBER, CA_SOCIAL_INSURANCE_NUMBER, CREDIT_DEBIT_CARD_CVV, CREDIT_DEBIT_CARD_EXPIRY, CREDIT_DEBIT_CARD_NUMBER, DRIVER_ID, EMAIL, INTERNATIONAL_BANK_ACCOUNT_NUMBER, IP_ADDRESS, LICENSE_PLATE, MAC_ADDRESS, NAME, PASSWORD, PHONE, PIN, SWIFT_CODE, UK_NATIONAL_HEALTH_SERVICE_NUMBER, UK_NATIONAL_INSURANCE_NUMBER, UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER, URL, USERNAME, US_BANK_ACCOUNT_NUMBER, US_BANK_ROUTING_NUMBER, US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER, US_PASSPORT_NUMBER, US_SOCIAL_SECURITY_NUMBER, VEHICLE_IDENTIFICATION_NUMBER
        action: "BLOCK", # required, accepts BLOCK, ANONYMIZE, NONE
        input_action: "BLOCK", # accepts BLOCK, ANONYMIZE, NONE
        output_action: "BLOCK", # accepts BLOCK, ANONYMIZE, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
    regexes_config: [
      {
        name: "GuardrailRegexConfigNameString", # required
        description: "GuardrailRegexConfigDescriptionString",
        pattern: "GuardrailRegexConfigPatternString", # required
        action: "BLOCK", # required, accepts BLOCK, ANONYMIZE, NONE
        input_action: "BLOCK", # accepts BLOCK, ANONYMIZE, NONE
        output_action: "BLOCK", # accepts BLOCK, ANONYMIZE, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
  },
  contextual_grounding_policy_config: {
    filters_config: [ # required
      {
        type: "GROUNDING", # required, accepts GROUNDING, RELEVANCE
        threshold: 1.0, # required
        action: "BLOCK", # accepts BLOCK, NONE
        enabled: false,
      },
    ],
  },
  automated_reasoning_policy_config: {
    policies: ["AutomatedReasoningPolicyArn"], # required
    confidence_threshold: 1.0,
  },
  cross_region_config: {
    guardrail_profile_identifier: "GuardrailCrossRegionGuardrailProfileIdentifier", # required
  },
  blocked_input_messaging: "GuardrailBlockedMessaging", # required
  blocked_outputs_messaging: "GuardrailBlockedMessaging", # required
  kms_key_id: "KmsKeyId",
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  client_request_token: "IdempotencyToken",
})

Response structure


resp.guardrail_id #=> String
resp.guardrail_arn #=> String
resp.version #=> String
resp.created_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :name (required, String) —

    The name to give the guardrail.

  • :description (String) —

    A description of the guardrail.

  • :topic_policy_config (Types::GuardrailTopicPolicyConfig) —

    The topic policies to configure for the guardrail.

  • :content_policy_config (Types::GuardrailContentPolicyConfig) —

    The content filter policies to configure for the guardrail.

  • :word_policy_config (Types::GuardrailWordPolicyConfig) —

    The word policy you configure for the guardrail.

  • :sensitive_information_policy_config (Types::GuardrailSensitiveInformationPolicyConfig) —

    The sensitive information policy to configure for the guardrail.

  • :contextual_grounding_policy_config (Types::GuardrailContextualGroundingPolicyConfig) —

    The contextual grounding policy configuration used to create a guardrail.

  • :automated_reasoning_policy_config (Types::GuardrailAutomatedReasoningPolicyConfig) —

    Optional configuration for integrating Automated Reasoning policies with the new guardrail.

  • :cross_region_config (Types::GuardrailCrossRegionConfig) —

    The system-defined guardrail profile that you’re using with your guardrail. Guardrail profiles define the destination Amazon Web Services Regions where guardrail inference requests can be automatically routed.

    For more information, see the [Amazon Bedrock User Guide].

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/guardrails-cross-region.html

  • :blocked_input_messaging (required, String) —

    The message to return when the guardrail blocks a prompt.

  • :blocked_outputs_messaging (required, String) —

    The message to return when the guardrail blocks a model response.

  • :kms_key_id (String) —

    The ARN of the KMS key that you use to encrypt the guardrail.

  • :tags (Array<Types::Tag>) —

    The tags that you want to attach to the guardrail.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the API request completes no more than once. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. For more information, see [Ensuring idempotency] in the *Amazon S3 User Guide*.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

    [1]: docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html

Returns:

See Also:



1988
1989
1990
1991
 
# File 'lib/aws-sdk-bedrock/client.rb', line 1988

def create_guardrail(params = {}, options = {})
  req = build_request(:create_guardrail, params)
  req.send_request(options)
end

#create_guardrail_version(params = {}) ⇒ Types::CreateGuardrailVersionResponse

Creates a version of the guardrail. Use this API to create a snapshot of the guardrail when you are satisfied with a configuration, or to compare the configuration with another version.

Examples:

Request syntax with placeholder values


resp = client.create_guardrail_version({
  guardrail_identifier: "GuardrailIdentifier", # required
  description: "GuardrailDescription",
  client_request_token: "IdempotencyToken",
})

Response structure


resp.guardrail_id #=> String
resp.version #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :guardrail_identifier (required, String) —

    The unique identifier of the guardrail. This can be an ID or the ARN.

  • :description (String) —

    A description of the guardrail version.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the API request completes no more than once. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. For more information, see [Ensuring idempotency] in the *Amazon S3 User Guide*.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

    [1]: docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html

Returns:

See Also:



2039
2040
2041
2042
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2039

def create_guardrail_version(params = {}, options = {})
  req = build_request(:create_guardrail_version, params)
  req.send_request(options)
end

#create_inference_profile(params = {}) ⇒ Types::CreateInferenceProfileResponse

Creates an application inference profile to track metrics and costs when invoking a model. To create an application inference profile for a foundation model in one region, specify the ARN of the model in that region. To create an application inference profile for a foundation model across multiple regions, specify the ARN of the system-defined inference profile that contains the regions that you want to route requests to. For more information, see [Increase throughput and resilience with cross-region inference in Amazon Bedrock]. in the Amazon Bedrock User Guide.

[1]: docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html

Examples:

Request syntax with placeholder values


resp = client.create_inference_profile({
  inference_profile_name: "InferenceProfileName", # required
  description: "InferenceProfileDescription",
  client_request_token: "IdempotencyToken",
  model_source: { # required
    copy_from: "InferenceProfileModelSourceArn",
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure


resp.inference_profile_arn #=> String
resp.status #=> String, one of "ACTIVE"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



2121
2122
2123
2124
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2121

def create_inference_profile(params = {}, options = {})
  req = build_request(:create_inference_profile, params)
  req.send_request(options)
end

#create_marketplace_model_endpoint(params = {}) ⇒ Types::CreateMarketplaceModelEndpointResponse

Creates an endpoint for a model from Amazon Bedrock Marketplace. The endpoint is hosted by Amazon SageMaker.

Examples:

Request syntax with placeholder values


resp = client.create_marketplace_model_endpoint({
  model_source_identifier: "ModelSourceIdentifier", # required
  endpoint_config: { # required
    sage_maker: {
      initial_instance_count: 1, # required
      instance_type: "InstanceType", # required
      execution_role: "RoleArn", # required
      kms_encryption_key: "KmsKeyId",
      vpc: {
        subnet_ids: ["SubnetId"], # required
        security_group_ids: ["SecurityGroupId"], # required
      },
    },
  },
  accept_eula: false,
  endpoint_name: "EndpointName", # required
  client_request_token: "IdempotencyToken",
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure


resp.marketplace_model_endpoint.endpoint_arn #=> String
resp.marketplace_model_endpoint.model_source_identifier #=> String
resp.marketplace_model_endpoint.status #=> String, one of "REGISTERED", "INCOMPATIBLE_ENDPOINT"
resp.marketplace_model_endpoint.status_message #=> String
resp.marketplace_model_endpoint.created_at #=> Time
resp.marketplace_model_endpoint.updated_at #=> Time
resp.marketplace_model_endpoint.endpoint_config.sage_maker.initial_instance_count #=> Integer
resp.marketplace_model_endpoint.endpoint_config.sage_maker.instance_type #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.execution_role #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.kms_encryption_key #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.subnet_ids #=> Array
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.subnet_ids[0] #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.security_group_ids #=> Array
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.security_group_ids[0] #=> String
resp.marketplace_model_endpoint.endpoint_status #=> String
resp.marketplace_model_endpoint.endpoint_status_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_source_identifier (required, String) —

    The ARN of the model from Amazon Bedrock Marketplace that you want to deploy to the endpoint.

  • :endpoint_config (required, Types::EndpointConfig) —

    The configuration for the endpoint, including the number and type of instances to use.

  • :accept_eula (Boolean) —

    Indicates whether you accept the end-user license agreement (EULA) for the model. Set to ‘true` to accept the EULA.

  • :endpoint_name (required, String) —

    The name of the endpoint. This name must be unique within your Amazon Web Services account and region.

  • :client_request_token (String) —

    A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. This token is listed as not required because Amazon Web Services SDKs automatically generate it for you and set this parameter. If you’re not using the Amazon Web Services SDK or the CLI, you must provide this token or the action will fail.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :tags (Array<Types::Tag>) —

    An array of key-value pairs to apply to the underlying Amazon SageMaker endpoint. You can use these tags to organize and identify your Amazon Web Services resources.

Returns:

See Also:



2214
2215
2216
2217
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2214

def create_marketplace_model_endpoint(params = {}, options = {})
  req = build_request(:create_marketplace_model_endpoint, params)
  req.send_request(options)
end

#create_model_copy_job(params = {}) ⇒ Types::CreateModelCopyJobResponse

Copies a model to another region so that it can be used there. For more information, see [Copy models to be used in other regions] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/copy-model.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.create_model_copy_job({
  source_model_arn: "ModelArn", # required
  target_model_name: "CustomModelName", # required
  model_kms_key_id: "KmsKeyId",
  target_model_tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  client_request_token: "IdempotencyToken",
})

Response structure


resp.job_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



2286
2287
2288
2289
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2286

def create_model_copy_job(params = {}, options = {})
  req = build_request(:create_model_copy_job, params)
  req.send_request(options)
end

#create_model_customization_job(params = {}) ⇒ Types::CreateModelCustomizationJobResponse

Creates a fine-tuning job to customize a base model.

You specify the base foundation model and the location of the training data. After the model-customization job completes successfully, your custom model resource will be ready to use. Amazon Bedrock returns validation loss metrics and output generations after the job completes.

For information on the format of training and validation data, see [Prepare the datasets].

Model-customization jobs are asynchronous and the completion time depends on the base model and the training/validation data size. To monitor a job, use the ‘GetModelCustomizationJob` operation to retrieve the job status.

For more information, see [Custom models] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/model-customization-prepare.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/custom-models.html [3]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.create_model_customization_job({
  job_name: "JobName", # required
  custom_model_name: "CustomModelName", # required
  role_arn: "RoleArn", # required
  client_request_token: "IdempotencyToken",
  base_model_identifier: "BaseModelIdentifier", # required
  customization_type: "FINE_TUNING", # accepts FINE_TUNING, CONTINUED_PRE_TRAINING, DISTILLATION, REINFORCEMENT_FINE_TUNING, IMPORTED
  custom_model_kms_key_id: "KmsKeyId",
  job_tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  custom_model_tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  training_data_config: { # required
    s3_uri: "S3Uri",
    invocation_logs_config: {
      use_prompt_response: false,
      invocation_log_source: { # required
        s3_uri: "S3Uri",
      },
      request_metadata_filters: {
        equals: {
          "RequestMetadataMapKeyString" => "RequestMetadataMapValueString",
        },
        not_equals: {
          "RequestMetadataMapKeyString" => "RequestMetadataMapValueString",
        },
        and_all: [
          {
            equals: {
              "RequestMetadataMapKeyString" => "RequestMetadataMapValueString",
            },
            not_equals: {
              "RequestMetadataMapKeyString" => "RequestMetadataMapValueString",
            },
          },
        ],
        or_all: [
          {
            equals: {
              "RequestMetadataMapKeyString" => "RequestMetadataMapValueString",
            },
            not_equals: {
              "RequestMetadataMapKeyString" => "RequestMetadataMapValueString",
            },
          },
        ],
      },
    },
  },
  validation_data_config: {
    validators: [ # required
      {
        s3_uri: "S3Uri", # required
      },
    ],
  },
  output_data_config: { # required
    s3_uri: "S3Uri", # required
  },
  hyper_parameters: {
    "String" => "String",
  },
  vpc_config: {
    subnet_ids: ["SubnetId"], # required
    security_group_ids: ["SecurityGroupId"], # required
  },
  customization_config: {
    distillation_config: {
      teacher_model_config: { # required
        teacher_model_identifier: "TeacherModelIdentifier", # required
        max_response_length_for_inference: 1,
      },
    },
    rft_config: {
      grader_config: {
        lambda_grader: {
          lambda_arn: "LambdaArn", # required
        },
      },
      hyper_parameters: {
        epoch_count: 1,
        batch_size: 1,
        learning_rate: 1.0,
        max_prompt_length: 1,
        training_sample_per_prompt: 1,
        inference_max_tokens: 1,
        reasoning_effort: "low", # accepts low, medium, high
        eval_interval: 1,
      },
    },
  },
})

Response structure


resp.job_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_name (required, String) —

    A name for the fine-tuning job.

  • :custom_model_name (required, String) —

    A name for the resulting custom model.

  • :role_arn (required, String) —

    The Amazon Resource Name (ARN) of an IAM service role that Amazon Bedrock can assume to perform tasks on your behalf. For example, during model training, Amazon Bedrock needs your permission to read input data from an S3 bucket, write model artifacts to an S3 bucket. To pass this role to Amazon Bedrock, the caller of this API must have the ‘iam:PassRole` permission.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. For more information, see [Ensuring idempotency].

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

    [1]: docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html

  • :base_model_identifier (required, String) —

    Name of the base model.

  • :customization_type (String) —

    The customization type.

  • :custom_model_kms_key_id (String) —

    The custom model is encrypted at rest using this key.

  • :job_tags (Array<Types::Tag>) —

    Tags to attach to the job.

  • :custom_model_tags (Array<Types::Tag>) —

    Tags to attach to the resulting custom model.

  • :training_data_config (required, Types::TrainingDataConfig) —

    Information about the training dataset.

  • :validation_data_config (Types::ValidationDataConfig) —

    Information about the validation dataset.

  • :output_data_config (required, Types::OutputDataConfig) —

    S3 location for the output data.

  • :hyper_parameters (Hash<String,String>) —

    Parameters related to tuning the model. For details on the format for different models, see [Custom model hyperparameters].

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/custom-models-hp.html

  • :vpc_config (Types::VpcConfig) —

    The configuration of the Virtual Private Cloud (VPC) that contains the resources that you’re using for this job. For more information, see [Protect your model customization jobs using a VPC].

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/vpc-model-customization.html

  • :customization_config (Types::CustomizationConfig) —

    The customization configuration for the model customization job.

Returns:

See Also:



2502
2503
2504
2505
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2502

def create_model_customization_job(params = {}, options = {})
  req = build_request(:create_model_customization_job, params)
  req.send_request(options)
end

#create_model_import_job(params = {}) ⇒ Types::CreateModelImportJobResponse

Creates a model import job to import model that you have customized in other environments, such as Amazon SageMaker. For more information, see [Import a customized model]

[1]: docs.aws.amazon.com/bedrock/latest/userguide/model-customization-import-model.html

Examples:

Request syntax with placeholder values


resp = client.create_model_import_job({
  job_name: "JobName", # required
  imported_model_name: "ImportedModelName", # required
  role_arn: "RoleArn", # required
  model_data_source: { # required
    s3_data_source: {
      s3_uri: "S3Uri", # required
    },
  },
  job_tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  imported_model_tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  client_request_token: "IdempotencyToken",
  vpc_config: {
    subnet_ids: ["SubnetId"], # required
    security_group_ids: ["SecurityGroupId"], # required
  },
  imported_model_kms_key_id: "KmsKeyId",
})

Response structure


resp.job_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_name (required, String) —

    The name of the import job.

  • :imported_model_name (required, String) —

    The name of the imported model.

  • :role_arn (required, String) —

    The Amazon Resource Name (ARN) of the model import job.

  • :model_data_source (required, Types::ModelDataSource) —

    The data source for the imported model.

  • :job_tags (Array<Types::Tag>) —

    Tags to attach to this import job.

  • :imported_model_tags (Array<Types::Tag>) —

    Tags to attach to the imported model.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the API request completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error. For more information, see [Ensuring idempotency].

    [1]: docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html

  • :vpc_config (Types::VpcConfig) —

    VPC configuration parameters for the private Virtual Private Cloud (VPC) that contains the resources you are using for the import job.

  • :imported_model_kms_key_id (String) —

    The imported model is encrypted at rest using this key.

Returns:

See Also:



2593
2594
2595
2596
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2593

def create_model_import_job(params = {}, options = {})
  req = build_request(:create_model_import_job, params)
  req.send_request(options)
end

#create_model_invocation_job(params = {}) ⇒ Types::CreateModelInvocationJobResponse

Creates a batch inference job to invoke a model on multiple prompts. Format your data according to [Format your inference data] and upload it to an Amazon S3 bucket. For more information, see [Process multiple prompts with batch inference].

The response returns a ‘jobArn` that you can use to stop or get details about the job.

[1]: docs.aws.amazon.com/bedrock/latest/userguide/batch-inference-data [2]: docs.aws.amazon.com/bedrock/latest/userguide/batch-inference.html

Examples:

Request syntax with placeholder values


resp = client.create_model_invocation_job({
  job_name: "ModelInvocationJobName", # required
  role_arn: "RoleArn", # required
  client_request_token: "ModelInvocationIdempotencyToken",
  model_id: "ModelId", # required
  input_data_config: { # required
    s3_input_data_config: {
      s3_input_format: "JSONL", # accepts JSONL
      s3_uri: "S3Uri", # required
      s3_bucket_owner: "AccountId",
    },
  },
  output_data_config: { # required
    s3_output_data_config: {
      s3_uri: "S3Uri", # required
      s3_encryption_key_id: "KmsKeyId",
      s3_bucket_owner: "AccountId",
    },
  },
  vpc_config: {
    subnet_ids: ["SubnetId"], # required
    security_group_ids: ["SecurityGroupId"], # required
  },
  timeout_duration_in_hours: 1,
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  model_invocation_type: "InvokeModel", # accepts InvokeModel, Converse
})

Response structure


resp.job_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



2718
2719
2720
2721
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2718

def create_model_invocation_job(params = {}, options = {})
  req = build_request(:create_model_invocation_job, params)
  req.send_request(options)
end

#create_prompt_router(params = {}) ⇒ Types::CreatePromptRouterResponse

Creates a prompt router that manages the routing of requests between multiple foundation models based on the routing criteria.

Examples:

Request syntax with placeholder values


resp = client.create_prompt_router({
  client_request_token: "IdempotencyToken",
  prompt_router_name: "PromptRouterName", # required
  models: [ # required
    {
      model_arn: "PromptRouterTargetModelArn", # required
    },
  ],
  description: "PromptRouterDescription",
  routing_criteria: { # required
    response_quality_difference: 1.0, # required
  },
  fallback_model: { # required
    model_arn: "PromptRouterTargetModelArn", # required
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure


resp.prompt_router_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :client_request_token (String) —

    A unique, case-sensitive identifier that you provide to ensure idempotency of your requests. If not specified, the Amazon Web Services SDK automatically generates one for you.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :prompt_router_name (required, String) —

    The name of the prompt router. The name must be unique within your Amazon Web Services account in the current region.

  • :models (required, Array<Types::PromptRouterTargetModel>) —

    A list of foundation models that the prompt router can route requests to. At least one model must be specified.

  • :description (String) —

    An optional description of the prompt router to help identify its purpose.

  • :routing_criteria (required, Types::RoutingCriteria) —

    The criteria, which is the response quality difference, used to determine how incoming requests are routed to different models.

  • :fallback_model (required, Types::PromptRouterTargetModel) —

    The default model to use when the routing criteria is not met.

  • :tags (Array<Types::Tag>) —

    An array of key-value pairs to apply to this resource as tags. You can use tags to categorize and manage your Amazon Web Services resources.

Returns:

See Also:



2794
2795
2796
2797
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2794

def create_prompt_router(params = {}, options = {})
  req = build_request(:create_prompt_router, params)
  req.send_request(options)
end

#create_provisioned_model_throughput(params = {}) ⇒ Types::CreateProvisionedModelThroughputResponse

Creates dedicated throughput for a base or custom model with the model units and for the duration that you specify. For pricing details, see [Amazon Bedrock Pricing]. For more information, see [Provisioned Throughput] in the [Amazon Bedrock User Guide].

[1]: aws.amazon.com/bedrock/pricing/ [2]: docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html [3]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.create_provisioned_model_throughput({
  client_request_token: "IdempotencyToken",
  model_units: 1, # required
  provisioned_model_name: "ProvisionedModelName", # required
  model_id: "ModelIdentifier", # required
  commitment_duration: "OneMonth", # accepts OneMonth, SixMonths
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure


resp.provisioned_model_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



2905
2906
2907
2908
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2905

def create_provisioned_model_throughput(params = {}, options = {})
  req = build_request(:create_provisioned_model_throughput, params)
  req.send_request(options)
end

#delete_automated_reasoning_policy(params = {}) ⇒ Struct

Deletes an Automated Reasoning policy or policy version. This operation is idempotent. If you delete a policy more than once, each call succeeds. Deleting a policy removes it permanently and cannot be undone.

Examples:

Request syntax with placeholder values


resp = client.delete_automated_reasoning_policy({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  force: false,
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy to delete.

  • :force (Boolean) —

    Specifies whether to force delete the automated reasoning policy even if it has active resources. When ‘false`, Amazon Bedrock validates if all artifacts have been deleted (e.g. policy version, test case, test result) for a policy before deletion. When `true`, Amazon Bedrock will delete the policy and all its artifacts without validation. Default is `false`.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2940
2941
2942
2943
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2940

def delete_automated_reasoning_policy(params = {}, options = {})
  req = build_request(:delete_automated_reasoning_policy, params)
  req.send_request(options)
end

#delete_automated_reasoning_policy_build_workflow(params = {}) ⇒ Struct

Deletes an Automated Reasoning policy build workflow and its associated artifacts. This permanently removes the workflow history and any generated assets.

Examples:

Request syntax with placeholder values


resp = client.delete_automated_reasoning_policy_build_workflow({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
  last_updated_at: Time.now, # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy whose build workflow you want to delete.

  • :build_workflow_id (required, String) —

    The unique identifier of the build workflow to delete.

  • :last_updated_at (required, Time, DateTime, Date, Integer, String) —

    The timestamp when the build workflow was last updated. This is used for optimistic concurrency control to prevent accidental deletion of workflows that have been modified.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2975
2976
2977
2978
 
# File 'lib/aws-sdk-bedrock/client.rb', line 2975

def delete_automated_reasoning_policy_build_workflow(params = {}, options = {})
  req = build_request(:delete_automated_reasoning_policy_build_workflow, params)
  req.send_request(options)
end

#delete_automated_reasoning_policy_test_case(params = {}) ⇒ Struct

Deletes an Automated Reasoning policy test. This operation is idempotent; if you delete a test more than once, each call succeeds.

Examples:

Request syntax with placeholder values


resp = client.delete_automated_reasoning_policy_test_case({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  test_case_id: "AutomatedReasoningPolicyTestCaseId", # required
  last_updated_at: Time.now, # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy that contains the test.

  • :test_case_id (required, String) —

    The unique identifier of the test to delete.

  • :last_updated_at (required, Time, DateTime, Date, Integer, String) —

    The timestamp when the test was last updated. This is used as a concurrency token to prevent conflicting modifications.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3008
3009
3010
3011
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3008

def delete_automated_reasoning_policy_test_case(params = {}, options = {})
  req = build_request(:delete_automated_reasoning_policy_test_case, params)
  req.send_request(options)
end

#delete_custom_model(params = {}) ⇒ Struct

Deletes a custom model that you created earlier. For more information, see [Custom models] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/custom-models.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.delete_custom_model({
  model_identifier: "ModelIdentifier", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_identifier (required, String) —

    Name of the model to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3036
3037
3038
3039
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3036

def delete_custom_model(params = {}, options = {})
  req = build_request(:delete_custom_model, params)
  req.send_request(options)
end

#delete_custom_model_deployment(params = {}) ⇒ Struct

Deletes a custom model deployment. This operation stops the deployment and removes it from your account. After deletion, the deployment ARN can no longer be used for inference requests.

The following actions are related to the ‘DeleteCustomModelDeployment` operation:

  • CreateCustomModelDeployment][1
  • GetCustomModelDeployment][2
  • ListCustomModelDeployments][3

[1]: docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateCustomModelDeployment.html [2]: docs.aws.amazon.com/bedrock/latest/APIReference/API_GetCustomModelDeployment.html [3]: docs.aws.amazon.com/bedrock/latest/APIReference/API_ListCustomModelDeployments.html

Examples:

Request syntax with placeholder values


resp = client.delete_custom_model_deployment({
  custom_model_deployment_identifier: "CustomModelDeploymentIdentifier", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :custom_model_deployment_identifier (required, String) —

    The Amazon Resource Name (ARN) or name of the custom model deployment to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3076
3077
3078
3079
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3076

def delete_custom_model_deployment(params = {}, options = {})
  req = build_request(:delete_custom_model_deployment, params)
  req.send_request(options)
end

#delete_enforced_guardrail_configuration(params = {}) ⇒ Struct

Deletes the account-level enforced guardrail configuration.

Examples:

Request syntax with placeholder values


resp = client.delete_enforced_guardrail_configuration({
  config_id: "AccountEnforcedGuardrailConfigurationId", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :config_id (required, String) —

    Unique ID for the account enforced configuration.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3098
3099
3100
3101
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3098

def delete_enforced_guardrail_configuration(params = {}, options = {})
  req = build_request(:delete_enforced_guardrail_configuration, params)
  req.send_request(options)
end

#delete_foundation_model_agreement(params = {}) ⇒ Struct

Delete the model access agreement for the specified model.

Examples:

Request syntax with placeholder values


resp = client.delete_foundation_model_agreement({
  model_id: "BedrockModelId", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_id (required, String) —

    Model Id of the model access to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3120
3121
3122
3123
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3120

def delete_foundation_model_agreement(params = {}, options = {})
  req = build_request(:delete_foundation_model_agreement, params)
  req.send_request(options)
end

#delete_guardrail(params = {}) ⇒ Struct

Deletes a guardrail.

  • To delete a guardrail, only specify the ARN of the guardrail in the ‘guardrailIdentifier` field. If you delete a guardrail, all of its versions will be deleted.

  • To delete a version of a guardrail, specify the ARN of the guardrail in the ‘guardrailIdentifier` field and the version in the `guardrailVersion` field.

Examples:

Request syntax with placeholder values


resp = client.delete_guardrail({
  guardrail_identifier: "GuardrailIdentifier", # required
  guardrail_version: "GuardrailNumericalVersion",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :guardrail_identifier (required, String) —

    The unique identifier of the guardrail. This can be an ID or the ARN.

  • :guardrail_version (String) —

    The version of the guardrail.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3154
3155
3156
3157
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3154

def delete_guardrail(params = {}, options = {})
  req = build_request(:delete_guardrail, params)
  req.send_request(options)
end

#delete_imported_model(params = {}) ⇒ Struct

Deletes a custom model that you imported earlier. For more information, see [Import a customized model] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/model-customization-import-model.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.delete_imported_model({
  model_identifier: "ImportedModelIdentifier", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_identifier (required, String) —

    Name of the imported model to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3183
3184
3185
3186
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3183

def delete_imported_model(params = {}, options = {})
  req = build_request(:delete_imported_model, params)
  req.send_request(options)
end

#delete_inference_profile(params = {}) ⇒ Struct

Deletes an application inference profile. For more information, see [Increase throughput and resilience with cross-region inference in Amazon Bedrock]. in the Amazon Bedrock User Guide.

[1]: docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html

Examples:

Request syntax with placeholder values


resp = client.delete_inference_profile({
  inference_profile_identifier: "InferenceProfileIdentifier", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :inference_profile_identifier (required, String) —

    The Amazon Resource Name (ARN) or ID of the application inference profile to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3212
3213
3214
3215
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3212

def delete_inference_profile(params = {}, options = {})
  req = build_request(:delete_inference_profile, params)
  req.send_request(options)
end

#delete_marketplace_model_endpoint(params = {}) ⇒ Struct

Deletes an endpoint for a model from Amazon Bedrock Marketplace.

Examples:

Request syntax with placeholder values


resp = client.delete_marketplace_model_endpoint({
  endpoint_arn: "Arn", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :endpoint_arn (required, String) —

    The Amazon Resource Name (ARN) of the endpoint you want to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3234
3235
3236
3237
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3234

def delete_marketplace_model_endpoint(params = {}, options = {})
  req = build_request(:delete_marketplace_model_endpoint, params)
  req.send_request(options)
end

#delete_model_invocation_logging_configuration(params = {}) ⇒ Struct

Delete the invocation logging.

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3247
3248
3249
3250
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3247

def delete_model_invocation_logging_configuration(params = {}, options = {})
  req = build_request(:delete_model_invocation_logging_configuration, params)
  req.send_request(options)
end

#delete_prompt_router(params = {}) ⇒ Struct

Deletes a specified prompt router. This action cannot be undone.

Examples:

Request syntax with placeholder values


resp = client.delete_prompt_router({
  prompt_router_arn: "PromptRouterArn", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :prompt_router_arn (required, String) —

    The Amazon Resource Name (ARN) of the prompt router to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3269
3270
3271
3272
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3269

def delete_prompt_router(params = {}, options = {})
  req = build_request(:delete_prompt_router, params)
  req.send_request(options)
end

#delete_provisioned_model_throughput(params = {}) ⇒ Struct

Deletes a Provisioned Throughput. You can’t delete a Provisioned Throughput before the commitment term is over. For more information, see [Provisioned Throughput] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.delete_provisioned_model_throughput({
  provisioned_model_id: "ProvisionedModelId", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :provisioned_model_id (required, String) —

    The Amazon Resource Name (ARN) or name of the Provisioned Throughput.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3298
3299
3300
3301
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3298

def delete_provisioned_model_throughput(params = {}, options = {})
  req = build_request(:delete_provisioned_model_throughput, params)
  req.send_request(options)
end

#delete_resource_policy(params = {}) ⇒ Struct

Deletes a previously created Bedrock resource policy.

Examples:

Request syntax with placeholder values


resp = client.delete_resource_policy({
  resource_arn: "ResourcePolicyResourceArn", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The ARN of the Bedrock resource to which this resource policy applies.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3320
3321
3322
3323
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3320

def delete_resource_policy(params = {}, options = {})
  req = build_request(:delete_resource_policy, params)
  req.send_request(options)
end

#deregister_marketplace_model_endpoint(params = {}) ⇒ Struct

Deregisters an endpoint for a model from Amazon Bedrock Marketplace. This operation removes the endpoint’s association with Amazon Bedrock but does not delete the underlying Amazon SageMaker endpoint.

Examples:

Request syntax with placeholder values


resp = client.deregister_marketplace_model_endpoint({
  endpoint_arn: "Arn", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :endpoint_arn (required, String) —

    The Amazon Resource Name (ARN) of the endpoint you want to deregister.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3344
3345
3346
3347
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3344

def deregister_marketplace_model_endpoint(params = {}, options = {})
  req = build_request(:deregister_marketplace_model_endpoint, params)
  req.send_request(options)
end

#export_automated_reasoning_policy_version(params = {}) ⇒ Types::ExportAutomatedReasoningPolicyVersionResponse

Exports the policy definition for an Automated Reasoning policy version. Returns the complete policy definition including rules, variables, and custom variable types in a structured format.

Examples:

Request syntax with placeholder values


resp = client.export_automated_reasoning_policy_version({
  policy_arn: "AutomatedReasoningPolicyArn", # required
})

Response structure


resp.policy_definition.version #=> String
resp.policy_definition.types #=> Array
resp.policy_definition.types[0].name #=> String
resp.policy_definition.types[0].description #=> String
resp.policy_definition.types[0].values #=> Array
resp.policy_definition.types[0].values[0].value #=> String
resp.policy_definition.types[0].values[0].description #=> String
resp.policy_definition.rules #=> Array
resp.policy_definition.rules[0].id #=> String
resp.policy_definition.rules[0].expression #=> String
resp.policy_definition.rules[0].alternate_expression #=> String
resp.policy_definition.variables #=> Array
resp.policy_definition.variables[0].name #=> String
resp.policy_definition.variables[0].type #=> String
resp.policy_definition.variables[0].description #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy to export. Can be either the unversioned ARN for the draft policy or a versioned ARN for a specific policy version.

Returns:

See Also:



3390
3391
3392
3393
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3390

def export_automated_reasoning_policy_version(params = {}, options = {})
  req = build_request(:export_automated_reasoning_policy_version, params)
  req.send_request(options)
end

#get_advanced_prompt_optimization_job(params = {}) ⇒ Types::GetAdvancedPromptOptimizationJobResponse

Retrieves the details and status of an advanced prompt optimization job.

Examples:

Request syntax with placeholder values


resp = client.get_advanced_prompt_optimization_job({
  job_identifier: "AdvancedPromptOptimizationJobIdentifier", # required
})

Response structure


resp.job_arn #=> String
resp.job_name #=> String
resp.job_description #=> String
resp.job_status #=> String, one of "InProgress", "Completed", "Failed", "PartiallyCompleted", "Stopping", "Stopped", "Deleting"
resp.input_config.s3_uri #=> String
resp.output_config.s3_uri #=> String
resp.encryption_key_arn #=> String
resp.creation_time #=> Time
resp.last_modified_time #=> Time
resp.failure_message #=> String
resp.model_configurations #=> Array
resp.model_configurations[0].model_id #=> String
resp.model_configurations[0].inference_config.max_tokens #=> Integer
resp.model_configurations[0].inference_config.temperature #=> Float
resp.model_configurations[0].inference_config.top_p #=> Float
resp.model_configurations[0].inference_config.stop_sequences #=> Array
resp.model_configurations[0].inference_config.stop_sequences[0] #=> String
resp.model_configurations[0].additional_model_request_fields #=> Hash

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    ARN or ID of the advanced prompt optimization job.

Returns:

See Also:



3446
3447
3448
3449
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3446

def get_advanced_prompt_optimization_job(params = {}, options = {})
  req = build_request(:get_advanced_prompt_optimization_job, params)
  req.send_request(options)
end

#get_automated_reasoning_policy(params = {}) ⇒ Types::GetAutomatedReasoningPolicyResponse

Retrieves details about an Automated Reasoning policy or policy version. Returns information including the policy definition, metadata, and timestamps.

Examples:

Request syntax with placeholder values


resp = client.get_automated_reasoning_policy({
  policy_arn: "AutomatedReasoningPolicyArn", # required
})

Response structure


resp.policy_arn #=> String
resp.name #=> String
resp.version #=> String
resp.policy_id #=> String
resp.description #=> String
resp.definition_hash #=> String
resp.kms_key_arn #=> String
resp.created_at #=> Time
resp.updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy to retrieve. Can be either the unversioned ARN for the draft policy or an ARN for a specific policy version.

Returns:

See Also:



3494
3495
3496
3497
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3494

def get_automated_reasoning_policy(params = {}, options = {})
  req = build_request(:get_automated_reasoning_policy, params)
  req.send_request(options)
end

#get_automated_reasoning_policy_annotations(params = {}) ⇒ Types::GetAutomatedReasoningPolicyAnnotationsResponse

Retrieves the current annotations for an Automated Reasoning policy build workflow. Annotations contain corrections to the rules, variables and types to be applied to the policy.

Examples:

Request syntax with placeholder values


resp = client.get_automated_reasoning_policy_annotations({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
})

Response structure


resp.policy_arn #=> String
resp.name #=> String
resp.build_workflow_id #=> String
resp.annotations #=> Array
resp.annotations[0].add_type.name #=> String
resp.annotations[0].add_type.description #=> String
resp.annotations[0].add_type.values #=> Array
resp.annotations[0].add_type.values[0].value #=> String
resp.annotations[0].add_type.values[0].description #=> String
resp.annotations[0].update_type.name #=> String
resp.annotations[0].update_type.new_name #=> String
resp.annotations[0].update_type.description #=> String
resp.annotations[0].update_type.values #=> Array
resp.annotations[0].update_type.values[0].add_type_value.value #=> String
resp.annotations[0].update_type.values[0].add_type_value.description #=> String
resp.annotations[0].update_type.values[0].update_type_value.value #=> String
resp.annotations[0].update_type.values[0].update_type_value.new_value #=> String
resp.annotations[0].update_type.values[0].update_type_value.description #=> String
resp.annotations[0].update_type.values[0].delete_type_value.value #=> String
resp.annotations[0].delete_type.name #=> String
resp.annotations[0].add_variable.name #=> String
resp.annotations[0].add_variable.type #=> String
resp.annotations[0].add_variable.description #=> String
resp.annotations[0].update_variable.name #=> String
resp.annotations[0].update_variable.new_name #=> String
resp.annotations[0].update_variable.description #=> String
resp.annotations[0].delete_variable.name #=> String
resp.annotations[0].add_rule.expression #=> String
resp.annotations[0].update_rule.rule_id #=> String
resp.annotations[0].update_rule.expression #=> String
resp.annotations[0].delete_rule.rule_id #=> String
resp.annotations[0].add_rule_from_natural_language.natural_language #=> String
resp.annotations[0].update_from_rules_feedback.rule_ids #=> Array
resp.annotations[0].update_from_rules_feedback.rule_ids[0] #=> String
resp.annotations[0].update_from_rules_feedback.feedback #=> String
resp.annotations[0].update_from_scenario_feedback.rule_ids #=> Array
resp.annotations[0].update_from_scenario_feedback.rule_ids[0] #=> String
resp.annotations[0].update_from_scenario_feedback.scenario_expression #=> String
resp.annotations[0].update_from_scenario_feedback.feedback #=> String
resp.annotations[0].ingest_content.content #=> String
resp.annotation_set_hash #=> String
resp.updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy whose annotations you want to retrieve.

  • :build_workflow_id (required, String) —

    The unique identifier of the build workflow whose annotations you want to retrieve.

Returns:

See Also:



3576
3577
3578
3579
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3576

def get_automated_reasoning_policy_annotations(params = {}, options = {})
  req = build_request(:get_automated_reasoning_policy_annotations, params)
  req.send_request(options)
end

#get_automated_reasoning_policy_build_workflow(params = {}) ⇒ Types::GetAutomatedReasoningPolicyBuildWorkflowResponse

Retrieves detailed information about an Automated Reasoning policy build workflow, including its status, configuration, and metadata.

Examples:

Request syntax with placeholder values


resp = client.get_automated_reasoning_policy_build_workflow({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
})

Response structure


resp.policy_arn #=> String
resp.build_workflow_id #=> String
resp.status #=> String, one of "SCHEDULED", "CANCEL_REQUESTED", "PREPROCESSING", "BUILDING", "TESTING", "COMPLETED", "FAILED", "CANCELLED"
resp.build_workflow_type #=> String, one of "INGEST_CONTENT", "REFINE_POLICY", "IMPORT_POLICY", "GENERATE_FIDELITY_REPORT", "GENERATE_POLICY_SCENARIOS"
resp.document_name #=> String
resp.document_content_type #=> String, one of "pdf", "txt"
resp.document_description #=> String
resp.created_at #=> Time
resp.updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy whose build workflow you want to retrieve.

  • :build_workflow_id (required, String) —

    The unique identifier of the build workflow to retrieve.

Returns:

See Also:



3626
3627
3628
3629
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3626

def get_automated_reasoning_policy_build_workflow(params = {}, options = {})
  req = build_request(:get_automated_reasoning_policy_build_workflow, params)
  req.send_request(options)
end

#get_automated_reasoning_policy_build_workflow_result_assets(params = {}) ⇒ Types::GetAutomatedReasoningPolicyBuildWorkflowResultAssetsResponse

Retrieves the resulting assets from a completed Automated Reasoning policy build workflow, including build logs, quality reports, and generated policy artifacts.

Examples:

Request syntax with placeholder values


resp = client.get_automated_reasoning_policy_build_workflow_result_assets({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
  asset_type: "BUILD_LOG", # required, accepts BUILD_LOG, QUALITY_REPORT, POLICY_DEFINITION, GENERATED_TEST_CASES, POLICY_SCENARIOS, FIDELITY_REPORT, ASSET_MANIFEST, SOURCE_DOCUMENT
  asset_id: "AutomatedReasoningPolicyBuildResultAssetId",
})

Response structure


resp.policy_arn #=> String
resp.build_workflow_id #=> String
resp.build_workflow_assets.policy_definition.version #=> String
resp.build_workflow_assets.policy_definition.types #=> Array
resp.build_workflow_assets.policy_definition.types[0].name #=> String
resp.build_workflow_assets.policy_definition.types[0].description #=> String
resp.build_workflow_assets.policy_definition.types[0].values #=> Array
resp.build_workflow_assets.policy_definition.types[0].values[0].value #=> String
resp.build_workflow_assets.policy_definition.types[0].values[0].description #=> String
resp.build_workflow_assets.policy_definition.rules #=> Array
resp.build_workflow_assets.policy_definition.rules[0].id #=> String
resp.build_workflow_assets.policy_definition.rules[0].expression #=> String
resp.build_workflow_assets.policy_definition.rules[0].alternate_expression #=> String
resp.build_workflow_assets.policy_definition.variables #=> Array
resp.build_workflow_assets.policy_definition.variables[0].name #=> String
resp.build_workflow_assets.policy_definition.variables[0].type #=> String
resp.build_workflow_assets.policy_definition.variables[0].description #=> String
resp.build_workflow_assets.quality_report.type_count #=> Integer
resp.build_workflow_assets.quality_report.variable_count #=> Integer
resp.build_workflow_assets.quality_report.rule_count #=> Integer
resp.build_workflow_assets.quality_report.unused_types #=> Array
resp.build_workflow_assets.quality_report.unused_types[0] #=> String
resp.build_workflow_assets.quality_report.unused_type_values #=> Array
resp.build_workflow_assets.quality_report.unused_type_values[0].type_name #=> String
resp.build_workflow_assets.quality_report.unused_type_values[0].value_name #=> String
resp.build_workflow_assets.quality_report.unused_variables #=> Array
resp.build_workflow_assets.quality_report.unused_variables[0] #=> String
resp.build_workflow_assets.quality_report.conflicting_rules #=> Array
resp.build_workflow_assets.quality_report.conflicting_rules[0] #=> String
resp.build_workflow_assets.quality_report.disjoint_rule_sets #=> Array
resp.build_workflow_assets.quality_report.disjoint_rule_sets[0].variables #=> Array
resp.build_workflow_assets.quality_report.disjoint_rule_sets[0].variables[0] #=> String
resp.build_workflow_assets.quality_report.disjoint_rule_sets[0].rules #=> Array
resp.build_workflow_assets.quality_report.disjoint_rule_sets[0].rules[0] #=> String
resp.build_workflow_assets.build_log.entries #=> Array
resp.build_workflow_assets.build_log.entries[0].annotation.add_type.name #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.add_type.description #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.add_type.values #=> Array
resp.build_workflow_assets.build_log.entries[0].annotation.add_type.values[0].value #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.add_type.values[0].description #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.name #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.new_name #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.description #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.values #=> Array
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.values[0].add_type_value.value #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.values[0].add_type_value.description #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.values[0].update_type_value.value #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.values[0].update_type_value.new_value #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.values[0].update_type_value.description #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_type.values[0].delete_type_value.value #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.delete_type.name #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.add_variable.name #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.add_variable.type #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.add_variable.description #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_variable.name #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_variable.new_name #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_variable.description #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.delete_variable.name #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.add_rule.expression #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_rule.rule_id #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_rule.expression #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.delete_rule.rule_id #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.add_rule_from_natural_language.natural_language #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_from_rules_feedback.rule_ids #=> Array
resp.build_workflow_assets.build_log.entries[0].annotation.update_from_rules_feedback.rule_ids[0] #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_from_rules_feedback.feedback #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_from_scenario_feedback.rule_ids #=> Array
resp.build_workflow_assets.build_log.entries[0].annotation.update_from_scenario_feedback.rule_ids[0] #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_from_scenario_feedback.scenario_expression #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.update_from_scenario_feedback.feedback #=> String
resp.build_workflow_assets.build_log.entries[0].annotation.ingest_content.content #=> String
resp.build_workflow_assets.build_log.entries[0].status #=> String, one of "APPLIED", "FAILED"
resp.build_workflow_assets.build_log.entries[0].build_steps #=> Array
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_type.type.name #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_type.type.description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_type.type.values #=> Array
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_type.type.values[0].value #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_type.type.values[0].description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_type.type.name #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_type.type.description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_type.type.values #=> Array
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_type.type.values[0].value #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_type.type.values[0].description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.delete_type.name #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_variable.variable.name #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_variable.variable.type #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_variable.variable.description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_variable.variable.name #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_variable.variable.type #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_variable.variable.description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.delete_variable.name #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_rule.rule.id #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_rule.rule.expression #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.add_rule.rule.alternate_expression #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_rule.rule.id #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_rule.rule.expression #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.update_rule.rule.alternate_expression #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].context.mutation.delete_rule.id #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_variable.name #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_variable.type #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_variable.description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_type.name #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_type.description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_type.values #=> Array
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_type.values[0].value #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_type.values[0].description #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_rule.id #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_rule.expression #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].prior_element.policy_definition_rule.alternate_expression #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].messages #=> Array
resp.build_workflow_assets.build_log.entries[0].build_steps[0].messages[0].message #=> String
resp.build_workflow_assets.build_log.entries[0].build_steps[0].messages[0].message_type #=> String, one of "INFO", "WARNING", "ERROR"
resp.build_workflow_assets.generated_test_cases.generated_test_cases #=> Array
resp.build_workflow_assets.generated_test_cases.generated_test_cases[0].query_content #=> String
resp.build_workflow_assets.generated_test_cases.generated_test_cases[0].guard_content #=> String
resp.build_workflow_assets.generated_test_cases.generated_test_cases[0].expected_aggregated_findings_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.build_workflow_assets.policy_scenarios.policy_scenarios #=> Array
resp.build_workflow_assets.policy_scenarios.policy_scenarios[0].expression #=> String
resp.build_workflow_assets.policy_scenarios.policy_scenarios[0].alternate_expression #=> String
resp.build_workflow_assets.policy_scenarios.policy_scenarios[0].expected_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.build_workflow_assets.policy_scenarios.policy_scenarios[0].rule_ids #=> Array
resp.build_workflow_assets.policy_scenarios.policy_scenarios[0].rule_ids[0] #=> String
resp.build_workflow_assets.asset_manifest.entries #=> Array
resp.build_workflow_assets.asset_manifest.entries[0].asset_type #=> String, one of "BUILD_LOG", "QUALITY_REPORT", "POLICY_DEFINITION", "GENERATED_TEST_CASES", "POLICY_SCENARIOS", "FIDELITY_REPORT", "ASSET_MANIFEST", "SOURCE_DOCUMENT"
resp.build_workflow_assets.asset_manifest.entries[0].asset_name #=> String
resp.build_workflow_assets.asset_manifest.entries[0].asset_id #=> String
resp.build_workflow_assets.document.document #=> String
resp.build_workflow_assets.document.document_content_type #=> String, one of "pdf", "txt"
resp.build_workflow_assets.document.document_name #=> String
resp.build_workflow_assets.document.document_description #=> String
resp.build_workflow_assets.document.document_hash #=> String
resp.build_workflow_assets.fidelity_report.coverage_score #=> Float
resp.build_workflow_assets.fidelity_report.accuracy_score #=> Float
resp.build_workflow_assets.fidelity_report.rule_reports #=> Hash
resp.build_workflow_assets.fidelity_report.rule_reports["AutomatedReasoningPolicyDefinitionRuleId"].rule #=> String
resp.build_workflow_assets.fidelity_report.rule_reports["AutomatedReasoningPolicyDefinitionRuleId"].grounding_statements #=> Array
resp.build_workflow_assets.fidelity_report.rule_reports["AutomatedReasoningPolicyDefinitionRuleId"].grounding_statements[0].document_id #=> String
resp.build_workflow_assets.fidelity_report.rule_reports["AutomatedReasoningPolicyDefinitionRuleId"].grounding_statements[0].statement_id #=> String
resp.build_workflow_assets.fidelity_report.rule_reports["AutomatedReasoningPolicyDefinitionRuleId"].grounding_justifications #=> Array
resp.build_workflow_assets.fidelity_report.rule_reports["AutomatedReasoningPolicyDefinitionRuleId"].grounding_justifications[0] #=> String
resp.build_workflow_assets.fidelity_report.rule_reports["AutomatedReasoningPolicyDefinitionRuleId"].accuracy_score #=> Float
resp.build_workflow_assets.fidelity_report.rule_reports["AutomatedReasoningPolicyDefinitionRuleId"].accuracy_justification #=> String
resp.build_workflow_assets.fidelity_report.variable_reports #=> Hash
resp.build_workflow_assets.fidelity_report.variable_reports["AutomatedReasoningPolicyDefinitionVariableName"].policy_variable #=> String
resp.build_workflow_assets.fidelity_report.variable_reports["AutomatedReasoningPolicyDefinitionVariableName"].grounding_statements #=> Array
resp.build_workflow_assets.fidelity_report.variable_reports["AutomatedReasoningPolicyDefinitionVariableName"].grounding_statements[0].document_id #=> String
resp.build_workflow_assets.fidelity_report.variable_reports["AutomatedReasoningPolicyDefinitionVariableName"].grounding_statements[0].statement_id #=> String
resp.build_workflow_assets.fidelity_report.variable_reports["AutomatedReasoningPolicyDefinitionVariableName"].grounding_justifications #=> Array
resp.build_workflow_assets.fidelity_report.variable_reports["AutomatedReasoningPolicyDefinitionVariableName"].grounding_justifications[0] #=> String
resp.build_workflow_assets.fidelity_report.variable_reports["AutomatedReasoningPolicyDefinitionVariableName"].accuracy_score #=> Float
resp.build_workflow_assets.fidelity_report.variable_reports["AutomatedReasoningPolicyDefinitionVariableName"].accuracy_justification #=> String
resp.build_workflow_assets.fidelity_report.document_sources #=> Array
resp.build_workflow_assets.fidelity_report.document_sources[0].document_name #=> String
resp.build_workflow_assets.fidelity_report.document_sources[0].document_hash #=> String
resp.build_workflow_assets.fidelity_report.document_sources[0].document_id #=> String
resp.build_workflow_assets.fidelity_report.document_sources[0].atomic_statements #=> Array
resp.build_workflow_assets.fidelity_report.document_sources[0].atomic_statements[0].id #=> String
resp.build_workflow_assets.fidelity_report.document_sources[0].atomic_statements[0].text #=> String
resp.build_workflow_assets.fidelity_report.document_sources[0].atomic_statements[0].location.lines #=> Array
resp.build_workflow_assets.fidelity_report.document_sources[0].atomic_statements[0].location.lines[0] #=> Integer
resp.build_workflow_assets.fidelity_report.document_sources[0].document_content #=> Array
resp.build_workflow_assets.fidelity_report.document_sources[0].document_content[0].page_number #=> Integer
resp.build_workflow_assets.fidelity_report.document_sources[0].document_content[0].content #=> Array
resp.build_workflow_assets.fidelity_report.document_sources[0].document_content[0].content[0].line.line_number #=> Integer
resp.build_workflow_assets.fidelity_report.document_sources[0].document_content[0].content[0].line.line_text #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy whose build workflow assets you want to retrieve.

  • :build_workflow_id (required, String) —

    The unique identifier of the build workflow whose result assets you want to retrieve.

  • :asset_type (required, String) —

    The type of asset to retrieve (e.g., BUILD_LOG, QUALITY_REPORT, POLICY_DEFINITION, GENERATED_TEST_CASES, POLICY_SCENARIOS, FIDELITY_REPORT, ASSET_MANIFEST, SOURCE_DOCUMENT).

  • :asset_id (String) —

    The unique identifier of the specific asset to retrieve when multiple assets of the same type exist. This is required when retrieving SOURCE_DOCUMENT assets, as multiple source documents may have been used in the workflow. The asset ID can be obtained from the asset manifest.

Returns:

See Also:



3842
3843
3844
3845
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3842

def get_automated_reasoning_policy_build_workflow_result_assets(params = {}, options = {})
  req = build_request(:get_automated_reasoning_policy_build_workflow_result_assets, params)
  req.send_request(options)
end

#get_automated_reasoning_policy_next_scenario(params = {}) ⇒ Types::GetAutomatedReasoningPolicyNextScenarioResponse

Retrieves the next test scenario for validating an Automated Reasoning policy. This is used during the interactive policy refinement process to test policy behavior.

Examples:

Request syntax with placeholder values


resp = client.get_automated_reasoning_policy_next_scenario({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
})

Response structure


resp.policy_arn #=> String
resp.scenario.expression #=> String
resp.scenario.alternate_expression #=> String
resp.scenario.expected_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.scenario.rule_ids #=> Array
resp.scenario.rule_ids[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy for which you want to get the next test scenario.

  • :build_workflow_id (required, String) —

    The unique identifier of the build workflow associated with the test scenarios.

Returns:

See Also:



3884
3885
3886
3887
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3884

def get_automated_reasoning_policy_next_scenario(params = {}, options = {})
  req = build_request(:get_automated_reasoning_policy_next_scenario, params)
  req.send_request(options)
end

#get_automated_reasoning_policy_test_case(params = {}) ⇒ Types::GetAutomatedReasoningPolicyTestCaseResponse

Retrieves details about a specific Automated Reasoning policy test.

Examples:

Request syntax with placeholder values


resp = client.get_automated_reasoning_policy_test_case({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  test_case_id: "AutomatedReasoningPolicyTestCaseId", # required
})

Response structure


resp.policy_arn #=> String
resp.test_case.test_case_id #=> String
resp.test_case.guard_content #=> String
resp.test_case.query_content #=> String
resp.test_case.expected_aggregated_findings_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.test_case.created_at #=> Time
resp.test_case.updated_at #=> Time
resp.test_case.confidence_threshold #=> Float

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy that contains the test.

  • :test_case_id (required, String) —

    The unique identifier of the test to retrieve.

Returns:

See Also:



3925
3926
3927
3928
 
# File 'lib/aws-sdk-bedrock/client.rb', line 3925

def get_automated_reasoning_policy_test_case(params = {}, options = {})
  req = build_request(:get_automated_reasoning_policy_test_case, params)
  req.send_request(options)
end

#get_automated_reasoning_policy_test_result(params = {}) ⇒ Types::GetAutomatedReasoningPolicyTestResultResponse

Retrieves the test result for a specific Automated Reasoning policy test. Returns detailed validation findings and execution status.

Examples:

Request syntax with placeholder values


resp = client.get_automated_reasoning_policy_test_result({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
  test_case_id: "AutomatedReasoningPolicyTestCaseId", # required
})

Response structure


resp.test_result.test_case.test_case_id #=> String
resp.test_result.test_case.guard_content #=> String
resp.test_result.test_case.query_content #=> String
resp.test_result.test_case.expected_aggregated_findings_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.test_result.test_case.created_at #=> Time
resp.test_result.test_case.updated_at #=> Time
resp.test_result.test_case.confidence_threshold #=> Float
resp.test_result.policy_arn #=> String
resp.test_result.test_run_status #=> String, one of "NOT_STARTED", "SCHEDULED", "IN_PROGRESS", "COMPLETED", "FAILED"
resp.test_result.test_findings #=> Array
resp.test_result.test_findings[0].valid.translation.premises #=> Array
resp.test_result.test_findings[0].valid.translation.premises[0].logic #=> String
resp.test_result.test_findings[0].valid.translation.premises[0].natural_language #=> String
resp.test_result.test_findings[0].valid.translation.claims #=> Array
resp.test_result.test_findings[0].valid.translation.claims[0].logic #=> String
resp.test_result.test_findings[0].valid.translation.claims[0].natural_language #=> String
resp.test_result.test_findings[0].valid.translation.untranslated_premises #=> Array
resp.test_result.test_findings[0].valid.translation.untranslated_premises[0].text #=> String
resp.test_result.test_findings[0].valid.translation.untranslated_claims #=> Array
resp.test_result.test_findings[0].valid.translation.untranslated_claims[0].text #=> String
resp.test_result.test_findings[0].valid.translation.confidence #=> Float
resp.test_result.test_findings[0].valid.claims_true_scenario.statements #=> Array
resp.test_result.test_findings[0].valid.claims_true_scenario.statements[0].logic #=> String
resp.test_result.test_findings[0].valid.claims_true_scenario.statements[0].natural_language #=> String
resp.test_result.test_findings[0].valid.supporting_rules #=> Array
resp.test_result.test_findings[0].valid.supporting_rules[0].id #=> String
resp.test_result.test_findings[0].valid.supporting_rules[0].policy_version_arn #=> String
resp.test_result.test_findings[0].valid.logic_warning.type #=> String, one of "ALWAYS_TRUE", "ALWAYS_FALSE"
resp.test_result.test_findings[0].valid.logic_warning.premises #=> Array
resp.test_result.test_findings[0].valid.logic_warning.premises[0].logic #=> String
resp.test_result.test_findings[0].valid.logic_warning.premises[0].natural_language #=> String
resp.test_result.test_findings[0].valid.logic_warning.claims #=> Array
resp.test_result.test_findings[0].valid.logic_warning.claims[0].logic #=> String
resp.test_result.test_findings[0].valid.logic_warning.claims[0].natural_language #=> String
resp.test_result.test_findings[0].invalid.translation.premises #=> Array
resp.test_result.test_findings[0].invalid.translation.premises[0].logic #=> String
resp.test_result.test_findings[0].invalid.translation.premises[0].natural_language #=> String
resp.test_result.test_findings[0].invalid.translation.claims #=> Array
resp.test_result.test_findings[0].invalid.translation.claims[0].logic #=> String
resp.test_result.test_findings[0].invalid.translation.claims[0].natural_language #=> String
resp.test_result.test_findings[0].invalid.translation.untranslated_premises #=> Array
resp.test_result.test_findings[0].invalid.translation.untranslated_premises[0].text #=> String
resp.test_result.test_findings[0].invalid.translation.untranslated_claims #=> Array
resp.test_result.test_findings[0].invalid.translation.untranslated_claims[0].text #=> String
resp.test_result.test_findings[0].invalid.translation.confidence #=> Float
resp.test_result.test_findings[0].invalid.contradicting_rules #=> Array
resp.test_result.test_findings[0].invalid.contradicting_rules[0].id #=> String
resp.test_result.test_findings[0].invalid.contradicting_rules[0].policy_version_arn #=> String
resp.test_result.test_findings[0].invalid.logic_warning.type #=> String, one of "ALWAYS_TRUE", "ALWAYS_FALSE"
resp.test_result.test_findings[0].invalid.logic_warning.premises #=> Array
resp.test_result.test_findings[0].invalid.logic_warning.premises[0].logic #=> String
resp.test_result.test_findings[0].invalid.logic_warning.premises[0].natural_language #=> String
resp.test_result.test_findings[0].invalid.logic_warning.claims #=> Array
resp.test_result.test_findings[0].invalid.logic_warning.claims[0].logic #=> String
resp.test_result.test_findings[0].invalid.logic_warning.claims[0].natural_language #=> String
resp.test_result.test_findings[0].satisfiable.translation.premises #=> Array
resp.test_result.test_findings[0].satisfiable.translation.premises[0].logic #=> String
resp.test_result.test_findings[0].satisfiable.translation.premises[0].natural_language #=> String
resp.test_result.test_findings[0].satisfiable.translation.claims #=> Array
resp.test_result.test_findings[0].satisfiable.translation.claims[0].logic #=> String
resp.test_result.test_findings[0].satisfiable.translation.claims[0].natural_language #=> String
resp.test_result.test_findings[0].satisfiable.translation.untranslated_premises #=> Array
resp.test_result.test_findings[0].satisfiable.translation.untranslated_premises[0].text #=> String
resp.test_result.test_findings[0].satisfiable.translation.untranslated_claims #=> Array
resp.test_result.test_findings[0].satisfiable.translation.untranslated_claims[0].text #=> String
resp.test_result.test_findings[0].satisfiable.translation.confidence #=> Float
resp.test_result.test_findings[0].satisfiable.claims_true_scenario.statements #=> Array
resp.test_result.test_findings[0].satisfiable.claims_true_scenario.statements[0].logic #=> String
resp.test_result.test_findings[0].satisfiable.claims_true_scenario.statements[0].natural_language #=> String
resp.test_result.test_findings[0].satisfiable.claims_false_scenario.statements #=> Array
resp.test_result.test_findings[0].satisfiable.claims_false_scenario.statements[0].logic #=> String
resp.test_result.test_findings[0].satisfiable.claims_false_scenario.statements[0].natural_language #=> String
resp.test_result.test_findings[0].satisfiable.logic_warning.type #=> String, one of "ALWAYS_TRUE", "ALWAYS_FALSE"
resp.test_result.test_findings[0].satisfiable.logic_warning.premises #=> Array
resp.test_result.test_findings[0].satisfiable.logic_warning.premises[0].logic #=> String
resp.test_result.test_findings[0].satisfiable.logic_warning.premises[0].natural_language #=> String
resp.test_result.test_findings[0].satisfiable.logic_warning.claims #=> Array
resp.test_result.test_findings[0].satisfiable.logic_warning.claims[0].logic #=> String
resp.test_result.test_findings[0].satisfiable.logic_warning.claims[0].natural_language #=> String
resp.test_result.test_findings[0].impossible.translation.premises #=> Array
resp.test_result.test_findings[0].impossible.translation.premises[0].logic #=> String
resp.test_result.test_findings[0].impossible.translation.premises[0].natural_language #=> String
resp.test_result.test_findings[0].impossible.translation.claims #=> Array
resp.test_result.test_findings[0].impossible.translation.claims[0].logic #=> String
resp.test_result.test_findings[0].impossible.translation.claims[0].natural_language #=> String
resp.test_result.test_findings[0].impossible.translation.untranslated_premises #=> Array
resp.test_result.test_findings[0].impossible.translation.untranslated_premises[0].text #=> String
resp.test_result.test_findings[0].impossible.translation.untranslated_claims #=> Array
resp.test_result.test_findings[0].impossible.translation.untranslated_claims[0].text #=> String
resp.test_result.test_findings[0].impossible.translation.confidence #=> Float
resp.test_result.test_findings[0].impossible.contradicting_rules #=> Array
resp.test_result.test_findings[0].impossible.contradicting_rules[0].id #=> String
resp.test_result.test_findings[0].impossible.contradicting_rules[0].policy_version_arn #=> String
resp.test_result.test_findings[0].impossible.logic_warning.type #=> String, one of "ALWAYS_TRUE", "ALWAYS_FALSE"
resp.test_result.test_findings[0].impossible.logic_warning.premises #=> Array
resp.test_result.test_findings[0].impossible.logic_warning.premises[0].logic #=> String
resp.test_result.test_findings[0].impossible.logic_warning.premises[0].natural_language #=> String
resp.test_result.test_findings[0].impossible.logic_warning.claims #=> Array
resp.test_result.test_findings[0].impossible.logic_warning.claims[0].logic #=> String
resp.test_result.test_findings[0].impossible.logic_warning.claims[0].natural_language #=> String
resp.test_result.test_findings[0].translation_ambiguous.options #=> Array
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations #=> Array
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].premises #=> Array
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].premises[0].logic #=> String
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].premises[0].natural_language #=> String
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].claims #=> Array
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].claims[0].logic #=> String
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].claims[0].natural_language #=> String
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].untranslated_premises #=> Array
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].untranslated_premises[0].text #=> String
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].untranslated_claims #=> Array
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].untranslated_claims[0].text #=> String
resp.test_result.test_findings[0].translation_ambiguous.options[0].translations[0].confidence #=> Float
resp.test_result.test_findings[0].translation_ambiguous.difference_scenarios #=> Array
resp.test_result.test_findings[0].translation_ambiguous.difference_scenarios[0].statements #=> Array
resp.test_result.test_findings[0].translation_ambiguous.difference_scenarios[0].statements[0].logic #=> String
resp.test_result.test_findings[0].translation_ambiguous.difference_scenarios[0].statements[0].natural_language #=> String
resp.test_result.test_run_result #=> String, one of "PASSED", "FAILED"
resp.test_result.aggregated_test_findings_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.test_result.updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy.

  • :build_workflow_id (required, String) —

    The build workflow identifier. The build workflow must display a ‘COMPLETED` status to get results.

  • :test_case_id (required, String) —

    The unique identifier of the test for which to retrieve results.

Returns:

See Also:



4082
4083
4084
4085
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4082

def get_automated_reasoning_policy_test_result(params = {}, options = {})
  req = build_request(:get_automated_reasoning_policy_test_result, params)
  req.send_request(options)
end

#get_custom_model(params = {}) ⇒ Types::GetCustomModelResponse

Get the properties associated with a Amazon Bedrock custom model that you have created. For more information, see [Custom models] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/custom-models.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.get_custom_model({
  model_identifier: "ModelIdentifier", # required
})

Response structure


resp.model_arn #=> String
resp.model_name #=> String
resp.job_name #=> String
resp.job_arn #=> String
resp.base_model_arn #=> String
resp.customization_type #=> String, one of "FINE_TUNING", "CONTINUED_PRE_TRAINING", "DISTILLATION", "REINFORCEMENT_FINE_TUNING", "IMPORTED"
resp.model_kms_key_arn #=> String
resp.hyper_parameters #=> Hash
resp.hyper_parameters["String"] #=> String
resp.training_data_config.s3_uri #=> String
resp.training_data_config.invocation_logs_config.use_prompt_response #=> Boolean
resp.training_data_config.invocation_logs_config.invocation_log_source.s3_uri #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.not_equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.not_equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all #=> Array
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all[0].equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all[0].equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all[0].not_equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all[0].not_equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all #=> Array
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all[0].equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all[0].equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all[0].not_equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all[0].not_equals["RequestMetadataMapKeyString"] #=> String
resp.validation_data_config.validators #=> Array
resp.validation_data_config.validators[0].s3_uri #=> String
resp.output_data_config.s3_uri #=> String
resp.training_metrics.training_loss #=> Float
resp.validation_metrics #=> Array
resp.validation_metrics[0].validation_loss #=> Float
resp.creation_time #=> Time
resp.customization_config.distillation_config.teacher_model_config.teacher_model_identifier #=> String
resp.customization_config.distillation_config.teacher_model_config.max_response_length_for_inference #=> Integer
resp.customization_config.rft_config.grader_config.lambda_grader.lambda_arn #=> String
resp.customization_config.rft_config.hyper_parameters.epoch_count #=> Integer
resp.customization_config.rft_config.hyper_parameters.batch_size #=> Integer
resp.customization_config.rft_config.hyper_parameters.learning_rate #=> Float
resp.customization_config.rft_config.hyper_parameters.max_prompt_length #=> Integer
resp.customization_config.rft_config.hyper_parameters.training_sample_per_prompt #=> Integer
resp.customization_config.rft_config.hyper_parameters.inference_max_tokens #=> Integer
resp.customization_config.rft_config.hyper_parameters.reasoning_effort #=> String, one of "low", "medium", "high"
resp.customization_config.rft_config.hyper_parameters.eval_interval #=> Integer
resp.model_status #=> String, one of "Active", "Creating", "Failed"
resp.failure_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_identifier (required, String) —

    Name or Amazon Resource Name (ARN) of the custom model.

Returns:

See Also:



4178
4179
4180
4181
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4178

def get_custom_model(params = {}, options = {})
  req = build_request(:get_custom_model, params)
  req.send_request(options)
end

#get_custom_model_deployment(params = {}) ⇒ Types::GetCustomModelDeploymentResponse

Retrieves information about a custom model deployment, including its status, configuration, and metadata. Use this operation to monitor the deployment status and retrieve details needed for inference requests.

The following actions are related to the ‘GetCustomModelDeployment` operation:

  • CreateCustomModelDeployment][1
  • ListCustomModelDeployments][2
  • DeleteCustomModelDeployment][3

[1]: docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateCustomModelDeployment.html [2]: docs.aws.amazon.com/bedrock/latest/APIReference/API_ListCustomModelDeployments.html [3]: docs.aws.amazon.com/bedrock/latest/APIReference/API_DeleteCustomModelDeployment.html

Examples:

Request syntax with placeholder values


resp = client.get_custom_model_deployment({
  custom_model_deployment_identifier: "CustomModelDeploymentIdentifier", # required
})

Response structure


resp.custom_model_deployment_arn #=> String
resp.model_deployment_name #=> String
resp.model_arn #=> String
resp.created_at #=> Time
resp.status #=> String, one of "Creating", "Active", "Failed"
resp.description #=> String
resp.update_details.model_arn #=> String
resp.update_details.update_status #=> String, one of "Updating", "UpdateCompleted", "UpdateFailed"
resp.failure_message #=> String
resp.last_updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :custom_model_deployment_identifier (required, String) —

    The Amazon Resource Name (ARN) or name of the custom model deployment to retrieve information about.

Returns:

See Also:



4241
4242
4243
4244
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4241

def get_custom_model_deployment(params = {}, options = {})
  req = build_request(:get_custom_model_deployment, params)
  req.send_request(options)
end

#get_evaluation_job(params = {}) ⇒ Types::GetEvaluationJobResponse

Gets information about an evaluation job, such as the status of the job.

Examples:

Request syntax with placeholder values


resp = client.get_evaluation_job({
  job_identifier: "EvaluationJobIdentifier", # required
})

Response structure


resp.job_name #=> String
resp.status #=> String, one of "InProgress", "Completed", "Failed", "Stopping", "Stopped", "Deleting"
resp.job_arn #=> String
resp.job_description #=> String
resp.role_arn #=> String
resp.customer_encryption_key_id #=> String
resp.job_type #=> String, one of "Human", "Automated"
resp.application_type #=> String, one of "ModelEvaluation", "RagEvaluation"
resp.evaluation_config.automated.dataset_metric_configs #=> Array
resp.evaluation_config.automated.dataset_metric_configs[0].task_type #=> String, one of "Summarization", "Classification", "QuestionAndAnswer", "Generation", "Custom"
resp.evaluation_config.automated.dataset_metric_configs[0].dataset.name #=> String
resp.evaluation_config.automated.dataset_metric_configs[0].dataset.dataset_location.s3_uri #=> String
resp.evaluation_config.automated.dataset_metric_configs[0].metric_names #=> Array
resp.evaluation_config.automated.dataset_metric_configs[0].metric_names[0] #=> String
resp.evaluation_config.automated.evaluator_model_config.bedrock_evaluator_models #=> Array
resp.evaluation_config.automated.evaluator_model_config.bedrock_evaluator_models[0].model_identifier #=> String
resp.evaluation_config.automated.custom_metric_config.custom_metrics #=> Array
resp.evaluation_config.automated.custom_metric_config.custom_metrics[0].custom_metric_definition.name #=> String
resp.evaluation_config.automated.custom_metric_config.custom_metrics[0].custom_metric_definition.instructions #=> String
resp.evaluation_config.automated.custom_metric_config.custom_metrics[0].custom_metric_definition.rating_scale #=> Array
resp.evaluation_config.automated.custom_metric_config.custom_metrics[0].custom_metric_definition.rating_scale[0].definition #=> String
resp.evaluation_config.automated.custom_metric_config.custom_metrics[0].custom_metric_definition.rating_scale[0].value.string_value #=> String
resp.evaluation_config.automated.custom_metric_config.custom_metrics[0].custom_metric_definition.rating_scale[0].value.float_value #=> Float
resp.evaluation_config.automated.custom_metric_config.evaluator_model_config.bedrock_evaluator_models #=> Array
resp.evaluation_config.automated.custom_metric_config.evaluator_model_config.bedrock_evaluator_models[0].model_identifier #=> String
resp.evaluation_config.human.human_workflow_config.flow_definition_arn #=> String
resp.evaluation_config.human.human_workflow_config.instructions #=> String
resp.evaluation_config.human.custom_metrics #=> Array
resp.evaluation_config.human.custom_metrics[0].name #=> String
resp.evaluation_config.human.custom_metrics[0].description #=> String
resp.evaluation_config.human.custom_metrics[0].rating_method #=> String
resp.evaluation_config.human.dataset_metric_configs #=> Array
resp.evaluation_config.human.dataset_metric_configs[0].task_type #=> String, one of "Summarization", "Classification", "QuestionAndAnswer", "Generation", "Custom"
resp.evaluation_config.human.dataset_metric_configs[0].dataset.name #=> String
resp.evaluation_config.human.dataset_metric_configs[0].dataset.dataset_location.s3_uri #=> String
resp.evaluation_config.human.dataset_metric_configs[0].metric_names #=> Array
resp.evaluation_config.human.dataset_metric_configs[0].metric_names[0] #=> String
resp.inference_config.models #=> Array
resp.inference_config.models[0].bedrock_model.model_identifier #=> String
resp.inference_config.models[0].bedrock_model.inference_params #=> String
resp.inference_config.models[0].bedrock_model.performance_config.latency #=> String, one of "standard", "optimized"
resp.inference_config.models[0].precomputed_inference_source.inference_source_identifier #=> String
resp.inference_config.rag_configs #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_id #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.number_of_results #=> Integer
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.override_search_type #=> String, one of "HYBRID", "SEMANTIC"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.equals.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.not_equals.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.greater_than.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.greater_than_or_equals.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.less_than.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.less_than_or_equals.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.in.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.not_in.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.starts_with.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.list_contains.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.string_contains.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.and_all #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.and_all[0] #=> Types::RetrievalFilter
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.or_all #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.filter.or_all[0] #=> Types::RetrievalFilter
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.implicit_filter_configuration.metadata_attributes #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.implicit_filter_configuration.metadata_attributes[0].key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.implicit_filter_configuration.metadata_attributes[0].type #=> String, one of "STRING", "NUMBER", "BOOLEAN", "STRING_LIST"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.implicit_filter_configuration.metadata_attributes[0].description #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.implicit_filter_configuration.model_arn #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.type #=> String, one of "BEDROCK_RERANKING_MODEL"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.model_configuration.model_arn #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.model_configuration.additional_model_request_fields #=> Hash
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.number_of_reranked_results #=> Integer
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selection_mode #=> String, one of "SELECTIVE", "ALL"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selective_mode_configuration.fields_to_include #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selective_mode_configuration.fields_to_include[0].field_name #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selective_mode_configuration.fields_to_exclude #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_config.knowledge_base_retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selective_mode_configuration.fields_to_exclude[0].field_name #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.type #=> String, one of "KNOWLEDGE_BASE", "EXTERNAL_SOURCES"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.knowledge_base_id #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.model_arn #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.number_of_results #=> Integer
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.override_search_type #=> String, one of "HYBRID", "SEMANTIC"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.equals.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.not_equals.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.greater_than.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.greater_than_or_equals.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.less_than.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.less_than_or_equals.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.in.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.not_in.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.starts_with.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.list_contains.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.string_contains.key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.and_all #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.and_all[0] #=> Types::RetrievalFilter
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.or_all #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.filter.or_all[0] #=> Types::RetrievalFilter
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.implicit_filter_configuration.metadata_attributes #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.implicit_filter_configuration.metadata_attributes[0].key #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.implicit_filter_configuration.metadata_attributes[0].type #=> String, one of "STRING", "NUMBER", "BOOLEAN", "STRING_LIST"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.implicit_filter_configuration.metadata_attributes[0].description #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.implicit_filter_configuration.model_arn #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.type #=> String, one of "BEDROCK_RERANKING_MODEL"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.model_configuration.model_arn #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.model_configuration.additional_model_request_fields #=> Hash
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.number_of_reranked_results #=> Integer
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selection_mode #=> String, one of "SELECTIVE", "ALL"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selective_mode_configuration.fields_to_include #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selective_mode_configuration.fields_to_include[0].field_name #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selective_mode_configuration.fields_to_exclude #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.retrieval_configuration.vector_search_configuration.reranking_configuration.bedrock_reranking_configuration.metadata_configuration.selective_mode_configuration.fields_to_exclude[0].field_name #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.prompt_template.text_prompt_template #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.guardrail_configuration.guardrail_id #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.guardrail_configuration.guardrail_version #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.kb_inference_config.text_inference_config.temperature #=> Float
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.kb_inference_config.text_inference_config.top_p #=> Float
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.kb_inference_config.text_inference_config.max_tokens #=> Integer
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.kb_inference_config.text_inference_config.stop_sequences #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.kb_inference_config.text_inference_config.stop_sequences[0] #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.generation_configuration.additional_model_request_fields #=> Hash
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.knowledge_base_configuration.orchestration_configuration.query_transformation_configuration.type #=> String, one of "QUERY_DECOMPOSITION"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.model_arn #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.sources #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.sources[0].source_type #=> String, one of "S3", "BYTE_CONTENT"
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.sources[0].s3_location.uri #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.sources[0].byte_content.identifier #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.sources[0].byte_content.content_type #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.sources[0].byte_content.data #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.prompt_template.text_prompt_template #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.guardrail_configuration.guardrail_id #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.guardrail_configuration.guardrail_version #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.kb_inference_config.text_inference_config.temperature #=> Float
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.kb_inference_config.text_inference_config.top_p #=> Float
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.kb_inference_config.text_inference_config.max_tokens #=> Integer
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.kb_inference_config.text_inference_config.stop_sequences #=> Array
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.kb_inference_config.text_inference_config.stop_sequences[0] #=> String
resp.inference_config.rag_configs[0].knowledge_base_config.retrieve_and_generate_config.external_sources_configuration.generation_configuration.additional_model_request_fields #=> Hash
resp.inference_config.rag_configs[0].precomputed_rag_source_config.retrieve_source_config.rag_source_identifier #=> String
resp.inference_config.rag_configs[0].precomputed_rag_source_config.retrieve_and_generate_source_config.rag_source_identifier #=> String
resp.output_data_config.s3_uri #=> String
resp.creation_time #=> Time
resp.last_modified_time #=> Time
resp.failure_messages #=> Array
resp.failure_messages[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    The Amazon Resource Name (ARN) of the evaluation job you want get information on.

Returns:

See Also:



4425
4426
4427
4428
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4425

def get_evaluation_job(params = {}, options = {})
  req = build_request(:get_evaluation_job, params)
  req.send_request(options)
end

#get_foundation_model(params = {}) ⇒ Types::GetFoundationModelResponse

Get details about a Amazon Bedrock foundation model.

Examples:

Request syntax with placeholder values


resp = client.get_foundation_model({
  model_identifier: "GetFoundationModelIdentifier", # required
})

Response structure


resp.model_details.model_arn #=> String
resp.model_details.model_id #=> String
resp.model_details.model_name #=> String
resp.model_details.provider_name #=> String
resp.model_details.input_modalities #=> Array
resp.model_details.input_modalities[0] #=> String, one of "TEXT", "IMAGE", "EMBEDDING"
resp.model_details.output_modalities #=> Array
resp.model_details.output_modalities[0] #=> String, one of "TEXT", "IMAGE", "EMBEDDING"
resp.model_details.response_streaming_supported #=> Boolean
resp.model_details.customizations_supported #=> Array
resp.model_details.customizations_supported[0] #=> String, one of "FINE_TUNING", "CONTINUED_PRE_TRAINING", "DISTILLATION"
resp.model_details.inference_types_supported #=> Array
resp.model_details.inference_types_supported[0] #=> String, one of "ON_DEMAND", "PROVISIONED"
resp.model_details.model_lifecycle.status #=> String, one of "ACTIVE", "LEGACY"
resp.model_details.model_lifecycle.start_of_life_time #=> Time
resp.model_details.model_lifecycle.end_of_life_time #=> Time
resp.model_details.model_lifecycle.legacy_time #=> Time
resp.model_details.model_lifecycle.public_extended_access_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_identifier (required, String) —

    The model identifier.

Returns:

See Also:



4470
4471
4472
4473
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4470

def get_foundation_model(params = {}, options = {})
  req = build_request(:get_foundation_model, params)
  req.send_request(options)
end

#get_foundation_model_availability(params = {}) ⇒ Types::GetFoundationModelAvailabilityResponse

Get information about the Foundation model availability.

Examples:

Request syntax with placeholder values


resp = client.get_foundation_model_availability({
  model_id: "BedrockModelId", # required
})

Response structure


resp.model_id #=> String
resp.agreement_availability.status #=> String, one of "AVAILABLE", "PENDING", "NOT_AVAILABLE", "ERROR"
resp.agreement_availability.error_message #=> String
resp.authorization_status #=> String, one of "AUTHORIZED", "NOT_AUTHORIZED"
resp.entitlement_availability #=> String, one of "AVAILABLE", "NOT_AVAILABLE"
resp.region_availability #=> String, one of "AVAILABLE", "NOT_AVAILABLE"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_id (required, String) —

    The model Id of the foundation model.

Returns:

See Also:



4507
4508
4509
4510
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4507

def get_foundation_model_availability(params = {}, options = {})
  req = build_request(:get_foundation_model_availability, params)
  req.send_request(options)
end

#get_guardrail(params = {}) ⇒ Types::GetGuardrailResponse

Gets details about a guardrail. If you don’t specify a version, the response returns details for the ‘DRAFT` version.

Examples:

Request syntax with placeholder values


resp = client.get_guardrail({
  guardrail_identifier: "GuardrailIdentifier", # required
  guardrail_version: "GuardrailVersion",
})

Response structure


resp.name #=> String
resp.description #=> String
resp.guardrail_id #=> String
resp.guardrail_arn #=> String
resp.version #=> String
resp.status #=> String, one of "CREATING", "UPDATING", "VERSIONING", "READY", "FAILED", "DELETING"
resp.topic_policy.topics #=> Array
resp.topic_policy.topics[0].name #=> String
resp.topic_policy.topics[0].definition #=> String
resp.topic_policy.topics[0].examples #=> Array
resp.topic_policy.topics[0].examples[0] #=> String
resp.topic_policy.topics[0].type #=> String, one of "DENY"
resp.topic_policy.topics[0].input_action #=> String, one of "BLOCK", "NONE"
resp.topic_policy.topics[0].output_action #=> String, one of "BLOCK", "NONE"
resp.topic_policy.topics[0].input_enabled #=> Boolean
resp.topic_policy.topics[0].output_enabled #=> Boolean
resp.topic_policy.tier.tier_name #=> String, one of "CLASSIC", "STANDARD"
resp.content_policy.filters #=> Array
resp.content_policy.filters[0].type #=> String, one of "SEXUAL", "VIOLENCE", "HATE", "INSULTS", "MISCONDUCT", "PROMPT_ATTACK"
resp.content_policy.filters[0].input_strength #=> String, one of "NONE", "LOW", "MEDIUM", "HIGH"
resp.content_policy.filters[0].output_strength #=> String, one of "NONE", "LOW", "MEDIUM", "HIGH"
resp.content_policy.filters[0].input_modalities #=> Array
resp.content_policy.filters[0].input_modalities[0] #=> String, one of "TEXT", "IMAGE"
resp.content_policy.filters[0].output_modalities #=> Array
resp.content_policy.filters[0].output_modalities[0] #=> String, one of "TEXT", "IMAGE"
resp.content_policy.filters[0].input_action #=> String, one of "BLOCK", "NONE"
resp.content_policy.filters[0].output_action #=> String, one of "BLOCK", "NONE"
resp.content_policy.filters[0].input_enabled #=> Boolean
resp.content_policy.filters[0].output_enabled #=> Boolean
resp.content_policy.tier.tier_name #=> String, one of "CLASSIC", "STANDARD"
resp.word_policy.words #=> Array
resp.word_policy.words[0].text #=> String
resp.word_policy.words[0].input_action #=> String, one of "BLOCK", "NONE"
resp.word_policy.words[0].output_action #=> String, one of "BLOCK", "NONE"
resp.word_policy.words[0].input_enabled #=> Boolean
resp.word_policy.words[0].output_enabled #=> Boolean
resp.word_policy.managed_word_lists #=> Array
resp.word_policy.managed_word_lists[0].type #=> String, one of "PROFANITY"
resp.word_policy.managed_word_lists[0].input_action #=> String, one of "BLOCK", "NONE"
resp.word_policy.managed_word_lists[0].output_action #=> String, one of "BLOCK", "NONE"
resp.word_policy.managed_word_lists[0].input_enabled #=> Boolean
resp.word_policy.managed_word_lists[0].output_enabled #=> Boolean
resp.sensitive_information_policy.pii_entities #=> Array
resp.sensitive_information_policy.pii_entities[0].type #=> String, one of "ADDRESS", "AGE", "AWS_ACCESS_KEY", "AWS_SECRET_KEY", "CA_HEALTH_NUMBER", "CA_SOCIAL_INSURANCE_NUMBER", "CREDIT_DEBIT_CARD_CVV", "CREDIT_DEBIT_CARD_EXPIRY", "CREDIT_DEBIT_CARD_NUMBER", "DRIVER_ID", "EMAIL", "INTERNATIONAL_BANK_ACCOUNT_NUMBER", "IP_ADDRESS", "LICENSE_PLATE", "MAC_ADDRESS", "NAME", "PASSWORD", "PHONE", "PIN", "SWIFT_CODE", "UK_NATIONAL_HEALTH_SERVICE_NUMBER", "UK_NATIONAL_INSURANCE_NUMBER", "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER", "URL", "USERNAME", "US_BANK_ACCOUNT_NUMBER", "US_BANK_ROUTING_NUMBER", "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER", "US_PASSPORT_NUMBER", "US_SOCIAL_SECURITY_NUMBER", "VEHICLE_IDENTIFICATION_NUMBER"
resp.sensitive_information_policy.pii_entities[0].action #=> String, one of "BLOCK", "ANONYMIZE", "NONE"
resp.sensitive_information_policy.pii_entities[0].input_action #=> String, one of "BLOCK", "ANONYMIZE", "NONE"
resp.sensitive_information_policy.pii_entities[0].output_action #=> String, one of "BLOCK", "ANONYMIZE", "NONE"
resp.sensitive_information_policy.pii_entities[0].input_enabled #=> Boolean
resp.sensitive_information_policy.pii_entities[0].output_enabled #=> Boolean
resp.sensitive_information_policy.regexes #=> Array
resp.sensitive_information_policy.regexes[0].name #=> String
resp.sensitive_information_policy.regexes[0].description #=> String
resp.sensitive_information_policy.regexes[0].pattern #=> String
resp.sensitive_information_policy.regexes[0].action #=> String, one of "BLOCK", "ANONYMIZE", "NONE"
resp.sensitive_information_policy.regexes[0].input_action #=> String, one of "BLOCK", "ANONYMIZE", "NONE"
resp.sensitive_information_policy.regexes[0].output_action #=> String, one of "BLOCK", "ANONYMIZE", "NONE"
resp.sensitive_information_policy.regexes[0].input_enabled #=> Boolean
resp.sensitive_information_policy.regexes[0].output_enabled #=> Boolean
resp.contextual_grounding_policy.filters #=> Array
resp.contextual_grounding_policy.filters[0].type #=> String, one of "GROUNDING", "RELEVANCE"
resp.contextual_grounding_policy.filters[0].threshold #=> Float
resp.contextual_grounding_policy.filters[0].action #=> String, one of "BLOCK", "NONE"
resp.contextual_grounding_policy.filters[0].enabled #=> Boolean
resp.automated_reasoning_policy.policies #=> Array
resp.automated_reasoning_policy.policies[0] #=> String
resp.automated_reasoning_policy.confidence_threshold #=> Float
resp.cross_region_details.guardrail_profile_id #=> String
resp.cross_region_details.guardrail_profile_arn #=> String
resp.created_at #=> Time
resp.updated_at #=> Time
resp.status_reasons #=> Array
resp.status_reasons[0] #=> String
resp.failure_recommendations #=> Array
resp.failure_recommendations[0] #=> String
resp.blocked_input_messaging #=> String
resp.blocked_outputs_messaging #=> String
resp.kms_key_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :guardrail_identifier (required, String) —

    The unique identifier of the guardrail for which to get details. This can be an ID or the ARN.

  • :guardrail_version (String) —

    The version of the guardrail for which to get details. If you don’t specify a version, the response returns details for the ‘DRAFT` version.

Returns:

See Also:



4638
4639
4640
4641
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4638

def get_guardrail(params = {}, options = {})
  req = build_request(:get_guardrail, params)
  req.send_request(options)
end

#get_imported_model(params = {}) ⇒ Types::GetImportedModelResponse

Gets properties associated with a customized model you imported.

Examples:

Request syntax with placeholder values


resp = client.get_imported_model({
  model_identifier: "ImportedModelIdentifier", # required
})

Response structure


resp.model_arn #=> String
resp.model_name #=> String
resp.job_name #=> String
resp.job_arn #=> String
resp.model_data_source.s3_data_source.s3_uri #=> String
resp.creation_time #=> Time
resp.model_architecture #=> String
resp.model_kms_key_arn #=> String
resp.instruct_supported #=> Boolean
resp.custom_model_units.custom_model_units_per_model_copy #=> Integer
resp.custom_model_units.custom_model_units_version #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_identifier (required, String) —

    Name or Amazon Resource Name (ARN) of the imported model.

Returns:

See Also:



4685
4686
4687
4688
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4685

def get_imported_model(params = {}, options = {})
  req = build_request(:get_imported_model, params)
  req.send_request(options)
end

#get_inference_profile(params = {}) ⇒ Types::GetInferenceProfileResponse

Gets information about an inference profile. For more information, see [Increase throughput and resilience with cross-region inference in Amazon Bedrock]. in the Amazon Bedrock User Guide.

[1]: docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html

Examples:

Request syntax with placeholder values


resp = client.get_inference_profile({
  inference_profile_identifier: "InferenceProfileIdentifier", # required
})

Response structure


resp.inference_profile_name #=> String
resp.description #=> String
resp.created_at #=> Time
resp.updated_at #=> Time
resp.inference_profile_arn #=> String
resp.models #=> Array
resp.models[0].model_arn #=> String
resp.inference_profile_id #=> String
resp.status #=> String, one of "ACTIVE"
resp.type #=> String, one of "SYSTEM_DEFINED", "APPLICATION"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :inference_profile_identifier (required, String) —

    The ID or Amazon Resource Name (ARN) of the inference profile.

Returns:

See Also:



4736
4737
4738
4739
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4736

def get_inference_profile(params = {}, options = {})
  req = build_request(:get_inference_profile, params)
  req.send_request(options)
end

#get_marketplace_model_endpoint(params = {}) ⇒ Types::GetMarketplaceModelEndpointResponse

Retrieves details about a specific endpoint for a model from Amazon Bedrock Marketplace.

Examples:

Request syntax with placeholder values


resp = client.get_marketplace_model_endpoint({
  endpoint_arn: "Arn", # required
})

Response structure


resp.marketplace_model_endpoint.endpoint_arn #=> String
resp.marketplace_model_endpoint.model_source_identifier #=> String
resp.marketplace_model_endpoint.status #=> String, one of "REGISTERED", "INCOMPATIBLE_ENDPOINT"
resp.marketplace_model_endpoint.status_message #=> String
resp.marketplace_model_endpoint.created_at #=> Time
resp.marketplace_model_endpoint.updated_at #=> Time
resp.marketplace_model_endpoint.endpoint_config.sage_maker.initial_instance_count #=> Integer
resp.marketplace_model_endpoint.endpoint_config.sage_maker.instance_type #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.execution_role #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.kms_encryption_key #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.subnet_ids #=> Array
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.subnet_ids[0] #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.security_group_ids #=> Array
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.security_group_ids[0] #=> String
resp.marketplace_model_endpoint.endpoint_status #=> String
resp.marketplace_model_endpoint.endpoint_status_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :endpoint_arn (required, String) —

    The Amazon Resource Name (ARN) of the endpoint you want to get information about.

Returns:

See Also:



4781
4782
4783
4784
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4781

def get_marketplace_model_endpoint(params = {}, options = {})
  req = build_request(:get_marketplace_model_endpoint, params)
  req.send_request(options)
end

#get_model_copy_job(params = {}) ⇒ Types::GetModelCopyJobResponse

Retrieves information about a model copy job. For more information, see [Copy models to be used in other regions] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/copy-model.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.get_model_copy_job({
  job_arn: "ModelCopyJobArn", # required
})

Response structure


resp.job_arn #=> String
resp.status #=> String, one of "InProgress", "Completed", "Failed"
resp.creation_time #=> Time
resp.target_model_arn #=> String
resp.target_model_name #=> String
resp. #=> String
resp.source_model_arn #=> String
resp.target_model_kms_key_arn #=> String
resp.target_model_tags #=> Array
resp.target_model_tags[0].key #=> String
resp.target_model_tags[0].value #=> String
resp.failure_message #=> String
resp.source_model_name #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_arn (required, String) —

    The Amazon Resource Name (ARN) of the model copy job.

Returns:

See Also:



4838
4839
4840
4841
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4838

def get_model_copy_job(params = {}, options = {})
  req = build_request(:get_model_copy_job, params)
  req.send_request(options)
end

#get_model_customization_job(params = {}) ⇒ Types::GetModelCustomizationJobResponse

Retrieves the properties associated with a model-customization job, including the status of the job. For more information, see [Custom models] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/custom-models.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.get_model_customization_job({
  job_identifier: "ModelCustomizationJobIdentifier", # required
})

Response structure


resp.job_arn #=> String
resp.job_name #=> String
resp.output_model_name #=> String
resp.output_model_arn #=> String
resp.client_request_token #=> String
resp.role_arn #=> String
resp.status #=> String, one of "InProgress", "Completed", "Failed", "Stopping", "Stopped"
resp.status_details.validation_details.status #=> String, one of "InProgress", "Completed", "Stopping", "Stopped", "Failed", "NotStarted"
resp.status_details.validation_details.creation_time #=> Time
resp.status_details.validation_details.last_modified_time #=> Time
resp.status_details.data_processing_details.status #=> String, one of "InProgress", "Completed", "Stopping", "Stopped", "Failed", "NotStarted"
resp.status_details.data_processing_details.creation_time #=> Time
resp.status_details.data_processing_details.last_modified_time #=> Time
resp.status_details.training_details.status #=> String, one of "InProgress", "Completed", "Stopping", "Stopped", "Failed", "NotStarted"
resp.status_details.training_details.creation_time #=> Time
resp.status_details.training_details.last_modified_time #=> Time
resp.failure_message #=> String
resp.creation_time #=> Time
resp.last_modified_time #=> Time
resp.end_time #=> Time
resp.base_model_arn #=> String
resp.hyper_parameters #=> Hash
resp.hyper_parameters["String"] #=> String
resp.training_data_config.s3_uri #=> String
resp.training_data_config.invocation_logs_config.use_prompt_response #=> Boolean
resp.training_data_config.invocation_logs_config.invocation_log_source.s3_uri #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.not_equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.not_equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all #=> Array
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all[0].equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all[0].equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all[0].not_equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.and_all[0].not_equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all #=> Array
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all[0].equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all[0].equals["RequestMetadataMapKeyString"] #=> String
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all[0].not_equals #=> Hash
resp.training_data_config.invocation_logs_config.request_metadata_filters.or_all[0].not_equals["RequestMetadataMapKeyString"] #=> String
resp.validation_data_config.validators #=> Array
resp.validation_data_config.validators[0].s3_uri #=> String
resp.output_data_config.s3_uri #=> String
resp.customization_type #=> String, one of "FINE_TUNING", "CONTINUED_PRE_TRAINING", "DISTILLATION", "REINFORCEMENT_FINE_TUNING", "IMPORTED"
resp.output_model_kms_key_arn #=> String
resp.training_metrics.training_loss #=> Float
resp.validation_metrics #=> Array
resp.validation_metrics[0].validation_loss #=> Float
resp.vpc_config.subnet_ids #=> Array
resp.vpc_config.subnet_ids[0] #=> String
resp.vpc_config.security_group_ids #=> Array
resp.vpc_config.security_group_ids[0] #=> String
resp.customization_config.distillation_config.teacher_model_config.teacher_model_identifier #=> String
resp.customization_config.distillation_config.teacher_model_config.max_response_length_for_inference #=> Integer
resp.customization_config.rft_config.grader_config.lambda_grader.lambda_arn #=> String
resp.customization_config.rft_config.hyper_parameters.epoch_count #=> Integer
resp.customization_config.rft_config.hyper_parameters.batch_size #=> Integer
resp.customization_config.rft_config.hyper_parameters.learning_rate #=> Float
resp.customization_config.rft_config.hyper_parameters.max_prompt_length #=> Integer
resp.customization_config.rft_config.hyper_parameters.training_sample_per_prompt #=> Integer
resp.customization_config.rft_config.hyper_parameters.inference_max_tokens #=> Integer
resp.customization_config.rft_config.hyper_parameters.reasoning_effort #=> String, one of "low", "medium", "high"
resp.customization_config.rft_config.hyper_parameters.eval_interval #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    Identifier for the customization job.

Returns:

See Also:



4957
4958
4959
4960
 
# File 'lib/aws-sdk-bedrock/client.rb', line 4957

def get_model_customization_job(params = {}, options = {})
  req = build_request(:get_model_customization_job, params)
  req.send_request(options)
end

#get_model_import_job(params = {}) ⇒ Types::GetModelImportJobResponse

Retrieves the properties associated with import model job, including the status of the job. For more information, see [Import a customized model] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/model-customization-import-model.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.get_model_import_job({
  job_identifier: "ModelImportJobIdentifier", # required
})

Response structure


resp.job_arn #=> String
resp.job_name #=> String
resp.imported_model_name #=> String
resp.imported_model_arn #=> String
resp.role_arn #=> String
resp.model_data_source.s3_data_source.s3_uri #=> String
resp.status #=> String, one of "InProgress", "Completed", "Failed"
resp.failure_message #=> String
resp.creation_time #=> Time
resp.last_modified_time #=> Time
resp.end_time #=> Time
resp.vpc_config.subnet_ids #=> Array
resp.vpc_config.subnet_ids[0] #=> String
resp.vpc_config.security_group_ids #=> Array
resp.vpc_config.security_group_ids[0] #=> String
resp.imported_model_kms_key_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    The identifier of the import job.

Returns:

See Also:



5019
5020
5021
5022
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5019

def get_model_import_job(params = {}, options = {})
  req = build_request(:get_model_import_job, params)
  req.send_request(options)
end

#get_model_invocation_job(params = {}) ⇒ Types::GetModelInvocationJobResponse

Gets details about a batch inference job. For more information, see

Monitor batch inference jobs][1

[1]: docs.aws.amazon.com/bedrock/latest/userguide/batch-inference-monitor

Examples:

Request syntax with placeholder values


resp = client.get_model_invocation_job({
  job_identifier: "ModelInvocationJobIdentifier", # required
})

Response structure


resp.job_arn #=> String
resp.job_name #=> String
resp.model_id #=> String
resp.client_request_token #=> String
resp.role_arn #=> String
resp.status #=> String, one of "Submitted", "InProgress", "Completed", "Failed", "Stopping", "Stopped", "PartiallyCompleted", "Expired", "Validating", "Scheduled"
resp.message #=> String
resp.submit_time #=> Time
resp.last_modified_time #=> Time
resp.end_time #=> Time
resp.input_data_config.s3_input_data_config.s3_input_format #=> String, one of "JSONL"
resp.input_data_config.s3_input_data_config.s3_uri #=> String
resp.input_data_config.s3_input_data_config.s3_bucket_owner #=> String
resp.output_data_config.s3_output_data_config.s3_uri #=> String
resp.output_data_config.s3_output_data_config.s3_encryption_key_id #=> String
resp.output_data_config.s3_output_data_config.s3_bucket_owner #=> String
resp.vpc_config.subnet_ids #=> Array
resp.vpc_config.subnet_ids[0] #=> String
resp.vpc_config.security_group_ids #=> Array
resp.vpc_config.security_group_ids[0] #=> String
resp.timeout_duration_in_hours #=> Integer
resp.job_expiration_time #=> Time
resp.model_invocation_type #=> String, one of "InvokeModel", "Converse"
resp.total_record_count #=> Integer
resp.processed_record_count #=> Integer
resp.success_record_count #=> Integer
resp.error_record_count #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    The Amazon Resource Name (ARN) of the batch inference job.

Returns:

See Also:



5097
5098
5099
5100
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5097

def get_model_invocation_job(params = {}, options = {})
  req = build_request(:get_model_invocation_job, params)
  req.send_request(options)
end

#get_model_invocation_logging_configuration(params = {}) ⇒ Types::GetModelInvocationLoggingConfigurationResponse

Get the current configuration values for model invocation logging.

Examples:

Response structure


resp.logging_config.cloud_watch_config.log_group_name #=> String
resp.logging_config.cloud_watch_config.role_arn #=> String
resp.logging_config.cloud_watch_config.large_data_delivery_s3_config.bucket_name #=> String
resp.logging_config.cloud_watch_config.large_data_delivery_s3_config.key_prefix #=> String
resp.logging_config.s3_config.bucket_name #=> String
resp.logging_config.s3_config.key_prefix #=> String
resp.logging_config.text_data_delivery_enabled #=> Boolean
resp.logging_config.image_data_delivery_enabled #=> Boolean
resp.logging_config.embedding_data_delivery_enabled #=> Boolean
resp.logging_config.video_data_delivery_enabled #=> Boolean
resp.logging_config.audio_data_delivery_enabled #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



5126
5127
5128
5129
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5126

def get_model_invocation_logging_configuration(params = {}, options = {})
  req = build_request(:get_model_invocation_logging_configuration, params)
  req.send_request(options)
end

#get_prompt_router(params = {}) ⇒ Types::GetPromptRouterResponse

Retrieves details about a prompt router.

Examples:

Request syntax with placeholder values


resp = client.get_prompt_router({
  prompt_router_arn: "PromptRouterArn", # required
})

Response structure


resp.prompt_router_name #=> String
resp.routing_criteria.response_quality_difference #=> Float
resp.description #=> String
resp.created_at #=> Time
resp.updated_at #=> Time
resp.prompt_router_arn #=> String
resp.models #=> Array
resp.models[0].model_arn #=> String
resp.fallback_model.model_arn #=> String
resp.status #=> String, one of "AVAILABLE"
resp.type #=> String, one of "custom", "default"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :prompt_router_arn (required, String) —

    The prompt router’s ARN

Returns:

See Also:



5173
5174
5175
5176
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5173

def get_prompt_router(params = {}, options = {})
  req = build_request(:get_prompt_router, params)
  req.send_request(options)
end

#get_provisioned_model_throughput(params = {}) ⇒ Types::GetProvisionedModelThroughputResponse

Returns details for a Provisioned Throughput. For more information, see [Provisioned Throughput] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.get_provisioned_model_throughput({
  provisioned_model_id: "ProvisionedModelId", # required
})

Response structure


resp.model_units #=> Integer
resp.desired_model_units #=> Integer
resp.provisioned_model_name #=> String
resp.provisioned_model_arn #=> String
resp.model_arn #=> String
resp.desired_model_arn #=> String
resp.foundation_model_arn #=> String
resp.status #=> String, one of "Creating", "InService", "Updating", "Failed"
resp.creation_time #=> Time
resp.last_modified_time #=> Time
resp.failure_message #=> String
resp.commitment_duration #=> String, one of "OneMonth", "SixMonths"
resp.commitment_expiration_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :provisioned_model_id (required, String) —

    The Amazon Resource Name (ARN) or name of the Provisioned Throughput.

Returns:

See Also:



5231
5232
5233
5234
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5231

def get_provisioned_model_throughput(params = {}, options = {})
  req = build_request(:get_provisioned_model_throughput, params)
  req.send_request(options)
end

#get_resource_policy(params = {}) ⇒ Types::GetResourcePolicyResponse

Gets the resource policy document for a Bedrock resource

Examples:

Request syntax with placeholder values


resp = client.get_resource_policy({
  resource_arn: "ResourcePolicyResourceArn", # required
})

Response structure


resp.resource_policy #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The ARN of the Bedrock resource to which this resource policy applies.

Returns:

See Also:



5259
5260
5261
5262
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5259

def get_resource_policy(params = {}, options = {})
  req = build_request(:get_resource_policy, params)
  req.send_request(options)
end

#get_use_case_for_model_access(params = {}) ⇒ Types::GetUseCaseForModelAccessResponse

Get usecase for model access.

Examples:

Response structure


resp.form_data #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



5278
5279
5280
5281
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5278

def get_use_case_for_model_access(params = {}, options = {})
  req = build_request(:get_use_case_for_model_access, params)
  req.send_request(options)
end

#list_advanced_prompt_optimization_jobs(params = {}) ⇒ Types::ListAdvancedPromptOptimizationJobsResponse

Lists all advanced prompt optimization jobs for the account.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_advanced_prompt_optimization_jobs({
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
})

Response structure


resp.job_summaries #=> Array
resp.job_summaries[0].job_arn #=> String
resp.job_summaries[0].job_name #=> String
resp.job_summaries[0].job_status #=> String, one of "InProgress", "Completed", "Failed", "PartiallyCompleted", "Stopping", "Stopped", "Deleting"
resp.job_summaries[0].creation_time #=> Time
resp.job_summaries[0].last_modified_time #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    Maximum number of results to return.

  • :next_token (String) —

    Pagination token for the next page of results.

  • :sort_by (String) —

    Field to sort by in the returned list of jobs.

  • :sort_order (String) —

    Sort order for the results.

Returns:

See Also:



5327
5328
5329
5330
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5327

def list_advanced_prompt_optimization_jobs(params = {}, options = {})
  req = build_request(:list_advanced_prompt_optimization_jobs, params)
  req.send_request(options)
end

#list_automated_reasoning_policies(params = {}) ⇒ Types::ListAutomatedReasoningPoliciesResponse

Lists all Automated Reasoning policies in your account, with optional filtering by policy ARN. This helps you manage and discover existing policies.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_automated_reasoning_policies({
  policy_arn: "AutomatedReasoningPolicyArn",
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.automated_reasoning_policy_summaries #=> Array
resp.automated_reasoning_policy_summaries[0].policy_arn #=> String
resp.automated_reasoning_policy_summaries[0].name #=> String
resp.automated_reasoning_policy_summaries[0].description #=> String
resp.automated_reasoning_policy_summaries[0].version #=> String
resp.automated_reasoning_policy_summaries[0].policy_id #=> String
resp.automated_reasoning_policy_summaries[0].created_at #=> Time
resp.automated_reasoning_policy_summaries[0].updated_at #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (String) —

    Optional filter to list only the policy versions with the specified Amazon Resource Name (ARN). If not provided, the DRAFT versions for all policies are listed.

  • :next_token (String) —

    The pagination token from a previous request to retrieve the next page of results.

  • :max_results (Integer) —

    The maximum number of policies to return in a single call.

Returns:

See Also:



5379
5380
5381
5382
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5379

def list_automated_reasoning_policies(params = {}, options = {})
  req = build_request(:list_automated_reasoning_policies, params)
  req.send_request(options)
end

#list_automated_reasoning_policy_build_workflows(params = {}) ⇒ Types::ListAutomatedReasoningPolicyBuildWorkflowsResponse

Lists all build workflows for an Automated Reasoning policy, showing the history of policy creation and modification attempts.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_automated_reasoning_policy_build_workflows({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.automated_reasoning_policy_build_workflow_summaries #=> Array
resp.automated_reasoning_policy_build_workflow_summaries[0].policy_arn #=> String
resp.automated_reasoning_policy_build_workflow_summaries[0].build_workflow_id #=> String
resp.automated_reasoning_policy_build_workflow_summaries[0].status #=> String, one of "SCHEDULED", "CANCEL_REQUESTED", "PREPROCESSING", "BUILDING", "TESTING", "COMPLETED", "FAILED", "CANCELLED"
resp.automated_reasoning_policy_build_workflow_summaries[0].build_workflow_type #=> String, one of "INGEST_CONTENT", "REFINE_POLICY", "IMPORT_POLICY", "GENERATE_FIDELITY_REPORT", "GENERATE_POLICY_SCENARIOS"
resp.automated_reasoning_policy_build_workflow_summaries[0].created_at #=> Time
resp.automated_reasoning_policy_build_workflow_summaries[0].updated_at #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy whose build workflows you want to list.

  • :next_token (String) —

    A pagination token from a previous request to continue listing build workflows from where the previous request left off.

  • :max_results (Integer) —

    The maximum number of build workflows to return in a single response. Valid range is 1-100.

Returns:

See Also:



5429
5430
5431
5432
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5429

def list_automated_reasoning_policy_build_workflows(params = {}, options = {})
  req = build_request(:list_automated_reasoning_policy_build_workflows, params)
  req.send_request(options)
end

#list_automated_reasoning_policy_test_cases(params = {}) ⇒ Types::ListAutomatedReasoningPolicyTestCasesResponse

Lists tests for an Automated Reasoning policy. We recommend using pagination to ensure that the operation returns quickly and successfully.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_automated_reasoning_policy_test_cases({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.test_cases #=> Array
resp.test_cases[0].test_case_id #=> String
resp.test_cases[0].guard_content #=> String
resp.test_cases[0].query_content #=> String
resp.test_cases[0].expected_aggregated_findings_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.test_cases[0].created_at #=> Time
resp.test_cases[0].updated_at #=> Time
resp.test_cases[0].confidence_threshold #=> Float
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy for which to list tests.

  • :next_token (String) —

    The pagination token from a previous request to retrieve the next page of results.

  • :max_results (Integer) —

    The maximum number of tests to return in a single call.

Returns:

See Also:



5480
5481
5482
5483
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5480

def list_automated_reasoning_policy_test_cases(params = {}, options = {})
  req = build_request(:list_automated_reasoning_policy_test_cases, params)
  req.send_request(options)
end

#list_automated_reasoning_policy_test_results(params = {}) ⇒ Types::ListAutomatedReasoningPolicyTestResultsResponse

Lists test results for an Automated Reasoning policy, showing how the policy performed against various test scenarios and validation checks.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_automated_reasoning_policy_test_results({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
  next_token: "PaginationToken",
  max_results: 1,
})

Response structure


resp.test_results #=> Array
resp.test_results[0].test_case.test_case_id #=> String
resp.test_results[0].test_case.guard_content #=> String
resp.test_results[0].test_case.query_content #=> String
resp.test_results[0].test_case.expected_aggregated_findings_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.test_results[0].test_case.created_at #=> Time
resp.test_results[0].test_case.updated_at #=> Time
resp.test_results[0].test_case.confidence_threshold #=> Float
resp.test_results[0].policy_arn #=> String
resp.test_results[0].test_run_status #=> String, one of "NOT_STARTED", "SCHEDULED", "IN_PROGRESS", "COMPLETED", "FAILED"
resp.test_results[0].test_findings #=> Array
resp.test_results[0].test_findings[0].valid.translation.premises #=> Array
resp.test_results[0].test_findings[0].valid.translation.premises[0].logic #=> String
resp.test_results[0].test_findings[0].valid.translation.premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].valid.translation.claims #=> Array
resp.test_results[0].test_findings[0].valid.translation.claims[0].logic #=> String
resp.test_results[0].test_findings[0].valid.translation.claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].valid.translation.untranslated_premises #=> Array
resp.test_results[0].test_findings[0].valid.translation.untranslated_premises[0].text #=> String
resp.test_results[0].test_findings[0].valid.translation.untranslated_claims #=> Array
resp.test_results[0].test_findings[0].valid.translation.untranslated_claims[0].text #=> String
resp.test_results[0].test_findings[0].valid.translation.confidence #=> Float
resp.test_results[0].test_findings[0].valid.claims_true_scenario.statements #=> Array
resp.test_results[0].test_findings[0].valid.claims_true_scenario.statements[0].logic #=> String
resp.test_results[0].test_findings[0].valid.claims_true_scenario.statements[0].natural_language #=> String
resp.test_results[0].test_findings[0].valid.supporting_rules #=> Array
resp.test_results[0].test_findings[0].valid.supporting_rules[0].id #=> String
resp.test_results[0].test_findings[0].valid.supporting_rules[0].policy_version_arn #=> String
resp.test_results[0].test_findings[0].valid.logic_warning.type #=> String, one of "ALWAYS_TRUE", "ALWAYS_FALSE"
resp.test_results[0].test_findings[0].valid.logic_warning.premises #=> Array
resp.test_results[0].test_findings[0].valid.logic_warning.premises[0].logic #=> String
resp.test_results[0].test_findings[0].valid.logic_warning.premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].valid.logic_warning.claims #=> Array
resp.test_results[0].test_findings[0].valid.logic_warning.claims[0].logic #=> String
resp.test_results[0].test_findings[0].valid.logic_warning.claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].invalid.translation.premises #=> Array
resp.test_results[0].test_findings[0].invalid.translation.premises[0].logic #=> String
resp.test_results[0].test_findings[0].invalid.translation.premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].invalid.translation.claims #=> Array
resp.test_results[0].test_findings[0].invalid.translation.claims[0].logic #=> String
resp.test_results[0].test_findings[0].invalid.translation.claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].invalid.translation.untranslated_premises #=> Array
resp.test_results[0].test_findings[0].invalid.translation.untranslated_premises[0].text #=> String
resp.test_results[0].test_findings[0].invalid.translation.untranslated_claims #=> Array
resp.test_results[0].test_findings[0].invalid.translation.untranslated_claims[0].text #=> String
resp.test_results[0].test_findings[0].invalid.translation.confidence #=> Float
resp.test_results[0].test_findings[0].invalid.contradicting_rules #=> Array
resp.test_results[0].test_findings[0].invalid.contradicting_rules[0].id #=> String
resp.test_results[0].test_findings[0].invalid.contradicting_rules[0].policy_version_arn #=> String
resp.test_results[0].test_findings[0].invalid.logic_warning.type #=> String, one of "ALWAYS_TRUE", "ALWAYS_FALSE"
resp.test_results[0].test_findings[0].invalid.logic_warning.premises #=> Array
resp.test_results[0].test_findings[0].invalid.logic_warning.premises[0].logic #=> String
resp.test_results[0].test_findings[0].invalid.logic_warning.premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].invalid.logic_warning.claims #=> Array
resp.test_results[0].test_findings[0].invalid.logic_warning.claims[0].logic #=> String
resp.test_results[0].test_findings[0].invalid.logic_warning.claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].satisfiable.translation.premises #=> Array
resp.test_results[0].test_findings[0].satisfiable.translation.premises[0].logic #=> String
resp.test_results[0].test_findings[0].satisfiable.translation.premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].satisfiable.translation.claims #=> Array
resp.test_results[0].test_findings[0].satisfiable.translation.claims[0].logic #=> String
resp.test_results[0].test_findings[0].satisfiable.translation.claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].satisfiable.translation.untranslated_premises #=> Array
resp.test_results[0].test_findings[0].satisfiable.translation.untranslated_premises[0].text #=> String
resp.test_results[0].test_findings[0].satisfiable.translation.untranslated_claims #=> Array
resp.test_results[0].test_findings[0].satisfiable.translation.untranslated_claims[0].text #=> String
resp.test_results[0].test_findings[0].satisfiable.translation.confidence #=> Float
resp.test_results[0].test_findings[0].satisfiable.claims_true_scenario.statements #=> Array
resp.test_results[0].test_findings[0].satisfiable.claims_true_scenario.statements[0].logic #=> String
resp.test_results[0].test_findings[0].satisfiable.claims_true_scenario.statements[0].natural_language #=> String
resp.test_results[0].test_findings[0].satisfiable.claims_false_scenario.statements #=> Array
resp.test_results[0].test_findings[0].satisfiable.claims_false_scenario.statements[0].logic #=> String
resp.test_results[0].test_findings[0].satisfiable.claims_false_scenario.statements[0].natural_language #=> String
resp.test_results[0].test_findings[0].satisfiable.logic_warning.type #=> String, one of "ALWAYS_TRUE", "ALWAYS_FALSE"
resp.test_results[0].test_findings[0].satisfiable.logic_warning.premises #=> Array
resp.test_results[0].test_findings[0].satisfiable.logic_warning.premises[0].logic #=> String
resp.test_results[0].test_findings[0].satisfiable.logic_warning.premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].satisfiable.logic_warning.claims #=> Array
resp.test_results[0].test_findings[0].satisfiable.logic_warning.claims[0].logic #=> String
resp.test_results[0].test_findings[0].satisfiable.logic_warning.claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].impossible.translation.premises #=> Array
resp.test_results[0].test_findings[0].impossible.translation.premises[0].logic #=> String
resp.test_results[0].test_findings[0].impossible.translation.premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].impossible.translation.claims #=> Array
resp.test_results[0].test_findings[0].impossible.translation.claims[0].logic #=> String
resp.test_results[0].test_findings[0].impossible.translation.claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].impossible.translation.untranslated_premises #=> Array
resp.test_results[0].test_findings[0].impossible.translation.untranslated_premises[0].text #=> String
resp.test_results[0].test_findings[0].impossible.translation.untranslated_claims #=> Array
resp.test_results[0].test_findings[0].impossible.translation.untranslated_claims[0].text #=> String
resp.test_results[0].test_findings[0].impossible.translation.confidence #=> Float
resp.test_results[0].test_findings[0].impossible.contradicting_rules #=> Array
resp.test_results[0].test_findings[0].impossible.contradicting_rules[0].id #=> String
resp.test_results[0].test_findings[0].impossible.contradicting_rules[0].policy_version_arn #=> String
resp.test_results[0].test_findings[0].impossible.logic_warning.type #=> String, one of "ALWAYS_TRUE", "ALWAYS_FALSE"
resp.test_results[0].test_findings[0].impossible.logic_warning.premises #=> Array
resp.test_results[0].test_findings[0].impossible.logic_warning.premises[0].logic #=> String
resp.test_results[0].test_findings[0].impossible.logic_warning.premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].impossible.logic_warning.claims #=> Array
resp.test_results[0].test_findings[0].impossible.logic_warning.claims[0].logic #=> String
resp.test_results[0].test_findings[0].impossible.logic_warning.claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].translation_ambiguous.options #=> Array
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations #=> Array
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].premises #=> Array
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].premises[0].logic #=> String
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].premises[0].natural_language #=> String
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].claims #=> Array
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].claims[0].logic #=> String
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].claims[0].natural_language #=> String
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].untranslated_premises #=> Array
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].untranslated_premises[0].text #=> String
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].untranslated_claims #=> Array
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].untranslated_claims[0].text #=> String
resp.test_results[0].test_findings[0].translation_ambiguous.options[0].translations[0].confidence #=> Float
resp.test_results[0].test_findings[0].translation_ambiguous.difference_scenarios #=> Array
resp.test_results[0].test_findings[0].translation_ambiguous.difference_scenarios[0].statements #=> Array
resp.test_results[0].test_findings[0].translation_ambiguous.difference_scenarios[0].statements[0].logic #=> String
resp.test_results[0].test_findings[0].translation_ambiguous.difference_scenarios[0].statements[0].natural_language #=> String
resp.test_results[0].test_run_result #=> String, one of "PASSED", "FAILED"
resp.test_results[0].aggregated_test_findings_result #=> String, one of "VALID", "INVALID", "SATISFIABLE", "IMPOSSIBLE", "TRANSLATION_AMBIGUOUS", "TOO_COMPLEX", "NO_TRANSLATION"
resp.test_results[0].updated_at #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy whose test results you want to list.

  • :build_workflow_id (required, String) —

    The unique identifier of the build workflow whose test results you want to list.

  • :next_token (String) —

    A pagination token from a previous request to continue listing test results from where the previous request left off.

  • :max_results (Integer) —

    The maximum number of test results to return in a single response. Valid range is 1-100.

Returns:

See Also:



5649
5650
5651
5652
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5649

def list_automated_reasoning_policy_test_results(params = {}, options = {})
  req = build_request(:list_automated_reasoning_policy_test_results, params)
  req.send_request(options)
end

#list_custom_model_deployments(params = {}) ⇒ Types::ListCustomModelDeploymentsResponse

Lists custom model deployments in your account. You can filter the results by creation time, name, status, and associated model. Use this operation to manage and monitor your custom model deployments.

We recommend using pagination to ensure that the operation returns quickly and successfully.

The following actions are related to the ‘ListCustomModelDeployments` operation:

  • CreateCustomModelDeployment][1
  • GetCustomModelDeployment][2
  • DeleteCustomModelDeployment][3

[1]: docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateCustomModelDeployment.html [2]: docs.aws.amazon.com/bedrock/latest/APIReference/API_GetCustomModelDeployment.html [3]: docs.aws.amazon.com/bedrock/latest/APIReference/API_DeleteCustomModelDeployment.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_custom_model_deployments({
  created_before: Time.now,
  created_after: Time.now,
  name_contains: "ModelDeploymentName",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
  status_equals: "Creating", # accepts Creating, Active, Failed
  model_arn_equals: "CustomModelArn",
})

Response structure


resp.next_token #=> String
resp.model_deployment_summaries #=> Array
resp.model_deployment_summaries[0].custom_model_deployment_arn #=> String
resp.model_deployment_summaries[0].custom_model_deployment_name #=> String
resp.model_deployment_summaries[0].model_arn #=> String
resp.model_deployment_summaries[0].created_at #=> Time
resp.model_deployment_summaries[0].status #=> String, one of "Creating", "Active", "Failed"
resp.model_deployment_summaries[0].last_updated_at #=> Time
resp.model_deployment_summaries[0].failure_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :created_before (Time, DateTime, Date, Integer, String) —

    Filters deployments created before the specified date and time.

  • :created_after (Time, DateTime, Date, Integer, String) —

    Filters deployments created after the specified date and time.

  • :name_contains (String) —

    Filters deployments whose names contain the specified string.

  • :max_results (Integer) —

    The maximum number of results to return in a single call.

  • :next_token (String) —

    The token for the next set of results. Use this token to retrieve additional results when the response is truncated.

  • :sort_by (String) —

    The field to sort the results by. The only supported value is ‘CreationTime`.

  • :sort_order (String) —

    The sort order for the results. Valid values are ‘Ascending` and `Descending`. Default is `Descending`.

  • :status_equals (String) —

    Filters deployments by status. Valid values are ‘CREATING`, `ACTIVE`, and `FAILED`.

  • :model_arn_equals (String) —

    Filters deployments by the Amazon Resource Name (ARN) of the associated custom model.

Returns:

See Also:



5745
5746
5747
5748
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5745

def list_custom_model_deployments(params = {}, options = {})
  req = build_request(:list_custom_model_deployments, params)
  req.send_request(options)
end

#list_custom_models(params = {}) ⇒ Types::ListCustomModelsResponse

Returns a list of the custom models that you have created with the ‘CreateModelCustomizationJob` operation.

For more information, see [Custom models] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/custom-models.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_custom_models({
  creation_time_before: Time.now,
  creation_time_after: Time.now,
  name_contains: "CustomModelName",
  base_model_arn_equals: "ModelArn",
  foundation_model_arn_equals: "FoundationModelArn",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
  is_owned: false,
  model_status: "Active", # accepts Active, Creating, Failed
})

Response structure


resp.next_token #=> String
resp.model_summaries #=> Array
resp.model_summaries[0].model_arn #=> String
resp.model_summaries[0].model_name #=> String
resp.model_summaries[0].creation_time #=> Time
resp.model_summaries[0].base_model_arn #=> String
resp.model_summaries[0].base_model_name #=> String
resp.model_summaries[0].customization_type #=> String, one of "FINE_TUNING", "CONTINUED_PRE_TRAINING", "DISTILLATION", "REINFORCEMENT_FINE_TUNING", "IMPORTED"
resp.model_summaries[0]. #=> String
resp.model_summaries[0].model_status #=> String, one of "Active", "Creating", "Failed"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creation_time_before (Time, DateTime, Date, Integer, String) —

    Return custom models created before the specified time.

  • :creation_time_after (Time, DateTime, Date, Integer, String) —

    Return custom models created after the specified time.

  • :name_contains (String) —

    Return custom models only if the job name contains these characters.

  • :base_model_arn_equals (String) —

    Return custom models only if the base model Amazon Resource Name (ARN) matches this parameter.

  • :foundation_model_arn_equals (String) —

    Return custom models only if the foundation model Amazon Resource Name (ARN) matches this parameter.

  • :max_results (Integer) —

    The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the ‘nextToken` field when making another request to return the next batch of results.

  • :next_token (String) —

    If the total number of results is greater than the ‘maxResults` value provided in the request, enter the token returned in the `nextToken` field in the response in this field to return the next batch of results.

  • :sort_by (String) —

    The field to sort by in the returned list of models.

  • :sort_order (String) —

    The sort order of the results.

  • :is_owned (Boolean) —

    Return custom models depending on if the current account owns them (‘true`) or if they were shared with the current account (`false`).

  • :model_status (String) —

    The status of them model to filter results by. Possible values include:

    • ‘Creating` - Include only models that are currently being created and validated.

    • ‘Active` - Include only models that have been successfully created and are ready for use.

    • ‘Failed` - Include only models where the creation process failed.

    If you don’t specify a status, the API returns models in all states.

Returns:

See Also:



5854
5855
5856
5857
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5854

def list_custom_models(params = {}, options = {})
  req = build_request(:list_custom_models, params)
  req.send_request(options)
end

#list_enforced_guardrails_configuration(params = {}) ⇒ Types::ListEnforcedGuardrailsConfigurationResponse

Lists the account-level enforced guardrail configurations.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_enforced_guardrails_configuration({
  next_token: "PaginationToken",
})

Response structure


resp.guardrails_config #=> Array
resp.guardrails_config[0].config_id #=> String
resp.guardrails_config[0].guardrail_arn #=> String
resp.guardrails_config[0].guardrail_id #=> String
resp.guardrails_config[0].input_tags #=> String, one of "HONOR", "IGNORE"
resp.guardrails_config[0].selective_content_guarding.system #=> String, one of "SELECTIVE", "COMPREHENSIVE"
resp.guardrails_config[0].selective_content_guarding.messages #=> String, one of "SELECTIVE", "COMPREHENSIVE"
resp.guardrails_config[0].guardrail_version #=> String
resp.guardrails_config[0].created_at #=> Time
resp.guardrails_config[0].created_by #=> String
resp.guardrails_config[0].updated_at #=> Time
resp.guardrails_config[0].updated_by #=> String
resp.guardrails_config[0].owner #=> String, one of "ACCOUNT"
resp.guardrails_config[0].model_enforcement.included_models #=> Array
resp.guardrails_config[0].model_enforcement.included_models[0] #=> String
resp.guardrails_config[0].model_enforcement.excluded_models #=> Array
resp.guardrails_config[0].model_enforcement.excluded_models[0] #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    Opaque continuation token of previous paginated response.

Returns:

See Also:



5902
5903
5904
5905
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5902

def list_enforced_guardrails_configuration(params = {}, options = {})
  req = build_request(:list_enforced_guardrails_configuration, params)
  req.send_request(options)
end

#list_evaluation_jobs(params = {}) ⇒ Types::ListEvaluationJobsResponse

Lists all existing evaluation jobs.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_evaluation_jobs({
  creation_time_after: Time.now,
  creation_time_before: Time.now,
  status_equals: "InProgress", # accepts InProgress, Completed, Failed, Stopping, Stopped, Deleting
  application_type_equals: "ModelEvaluation", # accepts ModelEvaluation, RagEvaluation
  name_contains: "EvaluationJobName",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
})

Response structure


resp.next_token #=> String
resp.job_summaries #=> Array
resp.job_summaries[0].job_arn #=> String
resp.job_summaries[0].job_name #=> String
resp.job_summaries[0].status #=> String, one of "InProgress", "Completed", "Failed", "Stopping", "Stopped", "Deleting"
resp.job_summaries[0].creation_time #=> Time
resp.job_summaries[0].job_type #=> String, one of "Human", "Automated"
resp.job_summaries[0].evaluation_task_types #=> Array
resp.job_summaries[0].evaluation_task_types[0] #=> String, one of "Summarization", "Classification", "QuestionAndAnswer", "Generation", "Custom"
resp.job_summaries[0].model_identifiers #=> Array
resp.job_summaries[0].model_identifiers[0] #=> String
resp.job_summaries[0].rag_identifiers #=> Array
resp.job_summaries[0].rag_identifiers[0] #=> String
resp.job_summaries[0].evaluator_model_identifiers #=> Array
resp.job_summaries[0].evaluator_model_identifiers[0] #=> String
resp.job_summaries[0].custom_metrics_evaluator_model_identifiers #=> Array
resp.job_summaries[0].custom_metrics_evaluator_model_identifiers[0] #=> String
resp.job_summaries[0].inference_config_summary.model_config_summary.bedrock_model_identifiers #=> Array
resp.job_summaries[0].inference_config_summary.model_config_summary.bedrock_model_identifiers[0] #=> String
resp.job_summaries[0].inference_config_summary.model_config_summary.precomputed_inference_source_identifiers #=> Array
resp.job_summaries[0].inference_config_summary.model_config_summary.precomputed_inference_source_identifiers[0] #=> String
resp.job_summaries[0].inference_config_summary.rag_config_summary.bedrock_knowledge_base_identifiers #=> Array
resp.job_summaries[0].inference_config_summary.rag_config_summary.bedrock_knowledge_base_identifiers[0] #=> String
resp.job_summaries[0].inference_config_summary.rag_config_summary.precomputed_rag_source_identifiers #=> Array
resp.job_summaries[0].inference_config_summary.rag_config_summary.precomputed_rag_source_identifiers[0] #=> String
resp.job_summaries[0].application_type #=> String, one of "ModelEvaluation", "RagEvaluation"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creation_time_after (Time, DateTime, Date, Integer, String) —

    A filter to only list evaluation jobs created after a specified time.

  • :creation_time_before (Time, DateTime, Date, Integer, String) —

    A filter to only list evaluation jobs created before a specified time.

  • :status_equals (String) —

    A filter to only list evaluation jobs that are of a certain status.

  • :application_type_equals (String) —

    A filter to only list evaluation jobs that are either model evaluations or knowledge base evaluations.

  • :name_contains (String) —

    A filter to only list evaluation jobs that contain a specified string in the job name.

  • :max_results (Integer) —

    The maximum number of results to return.

  • :next_token (String) —

    Continuation token from the previous response, for Amazon Bedrock to list the next set of results.

  • :sort_by (String) —

    Specifies a creation time to sort the list of evaluation jobs by when they were created.

  • :sort_order (String) —

    Specifies whether to sort the list of evaluation jobs by either ascending or descending order.

Returns:

See Also:



5995
5996
5997
5998
 
# File 'lib/aws-sdk-bedrock/client.rb', line 5995

def list_evaluation_jobs(params = {}, options = {})
  req = build_request(:list_evaluation_jobs, params)
  req.send_request(options)
end

#list_foundation_model_agreement_offers(params = {}) ⇒ Types::ListFoundationModelAgreementOffersResponse

Get the offers associated with the specified model.

Examples:

Request syntax with placeholder values


resp = client.list_foundation_model_agreement_offers({
  model_id: "BedrockModelId", # required
  offer_type: "ALL", # accepts ALL, PUBLIC
})

Response structure


resp.model_id #=> String
resp.offers #=> Array
resp.offers[0].offer_id #=> String
resp.offers[0].offer_token #=> String
resp.offers[0].term_details.usage_based_pricing_term.rate_card #=> Array
resp.offers[0].term_details.usage_based_pricing_term.rate_card[0].dimension #=> String
resp.offers[0].term_details.usage_based_pricing_term.rate_card[0].price #=> String
resp.offers[0].term_details.usage_based_pricing_term.rate_card[0].description #=> String
resp.offers[0].term_details.usage_based_pricing_term.rate_card[0].unit #=> String
resp.offers[0].term_details.legal_term.url #=> String
resp.offers[0].term_details.support_term.refund_policy_description #=> String
resp.offers[0].term_details.validity_term.agreement_duration #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_id (required, String) —

    Model Id of the foundation model.

  • :offer_type (String) —

    Type of offer associated with the model.

Returns:

See Also:



6039
6040
6041
6042
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6039

def list_foundation_model_agreement_offers(params = {}, options = {})
  req = build_request(:list_foundation_model_agreement_offers, params)
  req.send_request(options)
end

#list_foundation_models(params = {}) ⇒ Types::ListFoundationModelsResponse

Lists Amazon Bedrock foundation models that you can use. You can filter the results with the request parameters. For more information, see [Foundation models] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/foundation-models.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.list_foundation_models({
  by_provider: "Provider",
  by_customization_type: "FINE_TUNING", # accepts FINE_TUNING, CONTINUED_PRE_TRAINING, DISTILLATION
  by_output_modality: "TEXT", # accepts TEXT, IMAGE, EMBEDDING
  by_inference_type: "ON_DEMAND", # accepts ON_DEMAND, PROVISIONED
})

Response structure


resp.model_summaries #=> Array
resp.model_summaries[0].model_arn #=> String
resp.model_summaries[0].model_id #=> String
resp.model_summaries[0].model_name #=> String
resp.model_summaries[0].provider_name #=> String
resp.model_summaries[0].input_modalities #=> Array
resp.model_summaries[0].input_modalities[0] #=> String, one of "TEXT", "IMAGE", "EMBEDDING"
resp.model_summaries[0].output_modalities #=> Array
resp.model_summaries[0].output_modalities[0] #=> String, one of "TEXT", "IMAGE", "EMBEDDING"
resp.model_summaries[0].response_streaming_supported #=> Boolean
resp.model_summaries[0].customizations_supported #=> Array
resp.model_summaries[0].customizations_supported[0] #=> String, one of "FINE_TUNING", "CONTINUED_PRE_TRAINING", "DISTILLATION"
resp.model_summaries[0].inference_types_supported #=> Array
resp.model_summaries[0].inference_types_supported[0] #=> String, one of "ON_DEMAND", "PROVISIONED"
resp.model_summaries[0].model_lifecycle.status #=> String, one of "ACTIVE", "LEGACY"
resp.model_summaries[0].model_lifecycle.start_of_life_time #=> Time
resp.model_summaries[0].model_lifecycle.end_of_life_time #=> Time
resp.model_summaries[0].model_lifecycle.legacy_time #=> Time
resp.model_summaries[0].model_lifecycle.public_extended_access_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



6118
6119
6120
6121
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6118

def list_foundation_models(params = {}, options = {})
  req = build_request(:list_foundation_models, params)
  req.send_request(options)
end

#list_guardrails(params = {}) ⇒ Types::ListGuardrailsResponse

Lists details about all the guardrails in an account. To list the ‘DRAFT` version of all your guardrails, don’t specify the ‘guardrailIdentifier` field. To list all versions of a guardrail, specify the ARN of the guardrail in the `guardrailIdentifier` field.

You can set the maximum number of results to return in a response in the ‘maxResults` field. If there are more results than the number you set, the response returns a `nextToken` that you can send in another `ListGuardrails` request to see the next batch of results.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_guardrails({
  guardrail_identifier: "GuardrailIdentifier",
  max_results: 1,
  next_token: "PaginationToken",
})

Response structure


resp.guardrails #=> Array
resp.guardrails[0].id #=> String
resp.guardrails[0].arn #=> String
resp.guardrails[0].status #=> String, one of "CREATING", "UPDATING", "VERSIONING", "READY", "FAILED", "DELETING"
resp.guardrails[0].name #=> String
resp.guardrails[0].description #=> String
resp.guardrails[0].version #=> String
resp.guardrails[0].created_at #=> Time
resp.guardrails[0].updated_at #=> Time
resp.guardrails[0].cross_region_details.guardrail_profile_id #=> String
resp.guardrails[0].cross_region_details.guardrail_profile_arn #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :guardrail_identifier (String) —

    The unique identifier of the guardrail. This can be an ID or the ARN.

  • :max_results (Integer) —

    The maximum number of results to return in the response.

  • :next_token (String) —

    If there are more results than were returned in the response, the response returns a ‘nextToken` that you can send in another `ListGuardrails` request to see the next batch of results.

Returns:

See Also:



6178
6179
6180
6181
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6178

def list_guardrails(params = {}, options = {})
  req = build_request(:list_guardrails, params)
  req.send_request(options)
end

#list_imported_models(params = {}) ⇒ Types::ListImportedModelsResponse

Returns a list of models you’ve imported. You can filter the results to return based on one or more criteria. For more information, see

Import a customized model][1

in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/model-customization-import-model.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_imported_models({
  creation_time_before: Time.now,
  creation_time_after: Time.now,
  name_contains: "ImportedModelName",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
})

Response structure


resp.next_token #=> String
resp.model_summaries #=> Array
resp.model_summaries[0].model_arn #=> String
resp.model_summaries[0].model_name #=> String
resp.model_summaries[0].creation_time #=> Time
resp.model_summaries[0].instruct_supported #=> Boolean
resp.model_summaries[0].model_architecture #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creation_time_before (Time, DateTime, Date, Integer, String) —

    Return imported models that created before the specified time.

  • :creation_time_after (Time, DateTime, Date, Integer, String) —

    Return imported models that were created after the specified time.

  • :name_contains (String) —

    Return imported models only if the model name contains these characters.

  • :max_results (Integer) —

    The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the ‘nextToken` field when making another request to return the next batch of results.

  • :next_token (String) —

    If the total number of results is greater than the ‘maxResults` value provided in the request, enter the token returned in the `nextToken` field in the response in this field to return the next batch of results.

  • :sort_by (String) —

    The field to sort by in the returned list of imported models.

  • :sort_order (String) —

    Specifies whetehr to sort the results in ascending or descending order.

Returns:

See Also:



6254
6255
6256
6257
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6254

def list_imported_models(params = {}, options = {})
  req = build_request(:list_imported_models, params)
  req.send_request(options)
end

#list_inference_profiles(params = {}) ⇒ Types::ListInferenceProfilesResponse

Returns a list of inference profiles that you can use. For more information, see [Increase throughput and resilience with cross-region inference in Amazon Bedrock]. in the Amazon Bedrock User Guide.

[1]: docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_inference_profiles({
  max_results: 1,
  next_token: "PaginationToken",
  type_equals: "SYSTEM_DEFINED", # accepts SYSTEM_DEFINED, APPLICATION
})

Response structure


resp.inference_profile_summaries #=> Array
resp.inference_profile_summaries[0].inference_profile_name #=> String
resp.inference_profile_summaries[0].description #=> String
resp.inference_profile_summaries[0].created_at #=> Time
resp.inference_profile_summaries[0].updated_at #=> Time
resp.inference_profile_summaries[0].inference_profile_arn #=> String
resp.inference_profile_summaries[0].models #=> Array
resp.inference_profile_summaries[0].models[0].model_arn #=> String
resp.inference_profile_summaries[0].inference_profile_id #=> String
resp.inference_profile_summaries[0].status #=> String, one of "ACTIVE"
resp.inference_profile_summaries[0].type #=> String, one of "SYSTEM_DEFINED", "APPLICATION"
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the ‘nextToken` field when making another request to return the next batch of results.

  • :next_token (String) —

    If the total number of results is greater than the ‘maxResults` value provided in the request, enter the token returned in the `nextToken` field in the response in this field to return the next batch of results.

  • :type_equals (String) —

    Filters for inference profiles that match the type you specify.

    • ‘SYSTEM_DEFINED` – The inference profile is defined by Amazon Bedrock. You can route inference requests across regions with these inference profiles.

    • ‘APPLICATION` – The inference profile was created by a user. This type of inference profile can track metrics and costs when invoking the model in it. The inference profile may route requests to one or multiple regions.

Returns:

See Also:



6325
6326
6327
6328
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6325

def list_inference_profiles(params = {}, options = {})
  req = build_request(:list_inference_profiles, params)
  req.send_request(options)
end

#list_marketplace_model_endpoints(params = {}) ⇒ Types::ListMarketplaceModelEndpointsResponse

Lists the endpoints for models from Amazon Bedrock Marketplace in your Amazon Web Services account.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_marketplace_model_endpoints({
  max_results: 1,
  next_token: "PaginationToken",
  model_source_equals: "ModelSourceIdentifier",
})

Response structure


resp.marketplace_model_endpoints #=> Array
resp.marketplace_model_endpoints[0].endpoint_arn #=> String
resp.marketplace_model_endpoints[0].model_source_identifier #=> String
resp.marketplace_model_endpoints[0].status #=> String, one of "REGISTERED", "INCOMPATIBLE_ENDPOINT"
resp.marketplace_model_endpoints[0].status_message #=> String
resp.marketplace_model_endpoints[0].created_at #=> Time
resp.marketplace_model_endpoints[0].updated_at #=> Time
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of results to return in a single call. If more results are available, the operation returns a ‘NextToken` value.

  • :next_token (String) —

    The token for the next set of results. You receive this token from a previous ‘ListMarketplaceModelEndpoints` call.

  • :model_source_equals (String) —

    If specified, only endpoints for the given model source identifier are returned.

Returns:

See Also:



6375
6376
6377
6378
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6375

def list_marketplace_model_endpoints(params = {}, options = {})
  req = build_request(:list_marketplace_model_endpoints, params)
  req.send_request(options)
end

#list_model_copy_jobs(params = {}) ⇒ Types::ListModelCopyJobsResponse

Returns a list of model copy jobs that you have submitted. You can filter the jobs to return based on one or more criteria. For more information, see [Copy models to be used in other regions] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/copy-model.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_model_copy_jobs({
  creation_time_after: Time.now,
  creation_time_before: Time.now,
  status_equals: "InProgress", # accepts InProgress, Completed, Failed
  source_account_equals: "AccountId",
  source_model_arn_equals: "ModelArn",
  target_model_name_contains: "CustomModelName",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
})

Response structure


resp.next_token #=> String
resp.model_copy_job_summaries #=> Array
resp.model_copy_job_summaries[0].job_arn #=> String
resp.model_copy_job_summaries[0].status #=> String, one of "InProgress", "Completed", "Failed"
resp.model_copy_job_summaries[0].creation_time #=> Time
resp.model_copy_job_summaries[0].target_model_arn #=> String
resp.model_copy_job_summaries[0].target_model_name #=> String
resp.model_copy_job_summaries[0]. #=> String
resp.model_copy_job_summaries[0].source_model_arn #=> String
resp.model_copy_job_summaries[0].target_model_kms_key_arn #=> String
resp.model_copy_job_summaries[0].target_model_tags #=> Array
resp.model_copy_job_summaries[0].target_model_tags[0].key #=> String
resp.model_copy_job_summaries[0].target_model_tags[0].value #=> String
resp.model_copy_job_summaries[0].failure_message #=> String
resp.model_copy_job_summaries[0].source_model_name #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creation_time_after (Time, DateTime, Date, Integer, String) —

    Filters for model copy jobs created after the specified time.

  • :creation_time_before (Time, DateTime, Date, Integer, String) —

    Filters for model copy jobs created before the specified time.

  • :status_equals (String) —

    Filters for model copy jobs whose status matches the value that you specify.

  • :source_account_equals (String) —

    Filters for model copy jobs in which the account that the source model belongs to is equal to the value that you specify.

  • :source_model_arn_equals (String) —

    Filters for model copy jobs in which the Amazon Resource Name (ARN) of the source model to is equal to the value that you specify.

  • :target_model_name_contains (String) —

    Filters for model copy jobs in which the name of the copied model contains the string that you specify.

  • :max_results (Integer) —

    The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the ‘nextToken` field when making another request to return the next batch of results.

  • :next_token (String) —

    If the total number of results is greater than the ‘maxResults` value provided in the request, enter the token returned in the `nextToken` field in the response in this field to return the next batch of results.

  • :sort_by (String) —

    The field to sort by in the returned list of model copy jobs.

  • :sort_order (String) —

    Specifies whether to sort the results in ascending or descending order.

Returns:

See Also:



6475
6476
6477
6478
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6475

def list_model_copy_jobs(params = {}, options = {})
  req = build_request(:list_model_copy_jobs, params)
  req.send_request(options)
end

#list_model_customization_jobs(params = {}) ⇒ Types::ListModelCustomizationJobsResponse

Returns a list of model customization jobs that you have submitted. You can filter the jobs to return based on one or more criteria.

For more information, see [Custom models] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/custom-models.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_model_customization_jobs({
  creation_time_after: Time.now,
  creation_time_before: Time.now,
  status_equals: "InProgress", # accepts InProgress, Completed, Failed, Stopping, Stopped
  name_contains: "JobName",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
})

Response structure


resp.next_token #=> String
resp.model_customization_job_summaries #=> Array
resp.model_customization_job_summaries[0].job_arn #=> String
resp.model_customization_job_summaries[0].base_model_arn #=> String
resp.model_customization_job_summaries[0].job_name #=> String
resp.model_customization_job_summaries[0].status #=> String, one of "InProgress", "Completed", "Failed", "Stopping", "Stopped"
resp.model_customization_job_summaries[0].status_details.validation_details.status #=> String, one of "InProgress", "Completed", "Stopping", "Stopped", "Failed", "NotStarted"
resp.model_customization_job_summaries[0].status_details.validation_details.creation_time #=> Time
resp.model_customization_job_summaries[0].status_details.validation_details.last_modified_time #=> Time
resp.model_customization_job_summaries[0].status_details.data_processing_details.status #=> String, one of "InProgress", "Completed", "Stopping", "Stopped", "Failed", "NotStarted"
resp.model_customization_job_summaries[0].status_details.data_processing_details.creation_time #=> Time
resp.model_customization_job_summaries[0].status_details.data_processing_details.last_modified_time #=> Time
resp.model_customization_job_summaries[0].status_details.training_details.status #=> String, one of "InProgress", "Completed", "Stopping", "Stopped", "Failed", "NotStarted"
resp.model_customization_job_summaries[0].status_details.training_details.creation_time #=> Time
resp.model_customization_job_summaries[0].status_details.training_details.last_modified_time #=> Time
resp.model_customization_job_summaries[0].last_modified_time #=> Time
resp.model_customization_job_summaries[0].creation_time #=> Time
resp.model_customization_job_summaries[0].end_time #=> Time
resp.model_customization_job_summaries[0].custom_model_arn #=> String
resp.model_customization_job_summaries[0].custom_model_name #=> String
resp.model_customization_job_summaries[0].customization_type #=> String, one of "FINE_TUNING", "CONTINUED_PRE_TRAINING", "DISTILLATION", "REINFORCEMENT_FINE_TUNING", "IMPORTED"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creation_time_after (Time, DateTime, Date, Integer, String) —

    Return customization jobs created after the specified time.

  • :creation_time_before (Time, DateTime, Date, Integer, String) —

    Return customization jobs created before the specified time.

  • :status_equals (String) —

    Return customization jobs with the specified status.

  • :name_contains (String) —

    Return customization jobs only if the job name contains these characters.

  • :max_results (Integer) —

    The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the ‘nextToken` field when making another request to return the next batch of results.

  • :next_token (String) —

    If the total number of results is greater than the ‘maxResults` value provided in the request, enter the token returned in the `nextToken` field in the response in this field to return the next batch of results.

  • :sort_by (String) —

    The field to sort by in the returned list of jobs.

  • :sort_order (String) —

    The sort order of the results.

Returns:

See Also:



6570
6571
6572
6573
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6570

def list_model_customization_jobs(params = {}, options = {})
  req = build_request(:list_model_customization_jobs, params)
  req.send_request(options)
end

#list_model_import_jobs(params = {}) ⇒ Types::ListModelImportJobsResponse

Returns a list of import jobs you’ve submitted. You can filter the results to return based on one or more criteria. For more information, see [Import a customized model] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/model-customization-import-model.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_model_import_jobs({
  creation_time_after: Time.now,
  creation_time_before: Time.now,
  status_equals: "InProgress", # accepts InProgress, Completed, Failed
  name_contains: "JobName",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
})

Response structure


resp.next_token #=> String
resp.model_import_job_summaries #=> Array
resp.model_import_job_summaries[0].job_arn #=> String
resp.model_import_job_summaries[0].job_name #=> String
resp.model_import_job_summaries[0].status #=> String, one of "InProgress", "Completed", "Failed"
resp.model_import_job_summaries[0].last_modified_time #=> Time
resp.model_import_job_summaries[0].creation_time #=> Time
resp.model_import_job_summaries[0].end_time #=> Time
resp.model_import_job_summaries[0].imported_model_arn #=> String
resp.model_import_job_summaries[0].imported_model_name #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creation_time_after (Time, DateTime, Date, Integer, String) —

    Return import jobs that were created after the specified time.

  • :creation_time_before (Time, DateTime, Date, Integer, String) —

    Return import jobs that were created before the specified time.

  • :status_equals (String) —

    Return imported jobs with the specified status.

  • :name_contains (String) —

    Return imported jobs only if the job name contains these characters.

  • :max_results (Integer) —

    The maximum number of results to return in the response. If the total number of results is greater than this value, use the token returned in the response in the ‘nextToken` field when making another request to return the next batch of results.

  • :next_token (String) —

    If the total number of results is greater than the ‘maxResults` value provided in the request, enter the token returned in the `nextToken` field in the response in this field to return the next batch of results.

  • :sort_by (String) —

    The field to sort by in the returned list of imported jobs.

  • :sort_order (String) —

    Specifies whether to sort the results in ascending or descending order.

Returns:

See Also:



6653
6654
6655
6656
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6653

def list_model_import_jobs(params = {}, options = {})
  req = build_request(:list_model_import_jobs, params)
  req.send_request(options)
end

#list_model_invocation_jobs(params = {}) ⇒ Types::ListModelInvocationJobsResponse

Lists all batch inference jobs in the account. For more information, see [View details about a batch inference job].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/batch-inference-view.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_model_invocation_jobs({
  submit_time_after: Time.now,
  submit_time_before: Time.now,
  status_equals: "Submitted", # accepts Submitted, InProgress, Completed, Failed, Stopping, Stopped, PartiallyCompleted, Expired, Validating, Scheduled
  name_contains: "ModelInvocationJobName",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
})

Response structure


resp.next_token #=> String
resp.invocation_job_summaries #=> Array
resp.invocation_job_summaries[0].job_arn #=> String
resp.invocation_job_summaries[0].job_name #=> String
resp.invocation_job_summaries[0].model_id #=> String
resp.invocation_job_summaries[0].client_request_token #=> String
resp.invocation_job_summaries[0].role_arn #=> String
resp.invocation_job_summaries[0].status #=> String, one of "Submitted", "InProgress", "Completed", "Failed", "Stopping", "Stopped", "PartiallyCompleted", "Expired", "Validating", "Scheduled"
resp.invocation_job_summaries[0].message #=> String
resp.invocation_job_summaries[0].submit_time #=> Time
resp.invocation_job_summaries[0].last_modified_time #=> Time
resp.invocation_job_summaries[0].end_time #=> Time
resp.invocation_job_summaries[0].input_data_config.s3_input_data_config.s3_input_format #=> String, one of "JSONL"
resp.invocation_job_summaries[0].input_data_config.s3_input_data_config.s3_uri #=> String
resp.invocation_job_summaries[0].input_data_config.s3_input_data_config.s3_bucket_owner #=> String
resp.invocation_job_summaries[0].output_data_config.s3_output_data_config.s3_uri #=> String
resp.invocation_job_summaries[0].output_data_config.s3_output_data_config.s3_encryption_key_id #=> String
resp.invocation_job_summaries[0].output_data_config.s3_output_data_config.s3_bucket_owner #=> String
resp.invocation_job_summaries[0].vpc_config.subnet_ids #=> Array
resp.invocation_job_summaries[0].vpc_config.subnet_ids[0] #=> String
resp.invocation_job_summaries[0].vpc_config.security_group_ids #=> Array
resp.invocation_job_summaries[0].vpc_config.security_group_ids[0] #=> String
resp.invocation_job_summaries[0].timeout_duration_in_hours #=> Integer
resp.invocation_job_summaries[0].job_expiration_time #=> Time
resp.invocation_job_summaries[0].model_invocation_type #=> String, one of "InvokeModel", "Converse"
resp.invocation_job_summaries[0].total_record_count #=> Integer
resp.invocation_job_summaries[0].processed_record_count #=> Integer
resp.invocation_job_summaries[0].success_record_count #=> Integer
resp.invocation_job_summaries[0].error_record_count #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :submit_time_after (Time, DateTime, Date, Integer, String) —

    Specify a time to filter for batch inference jobs that were submitted after the time you specify.

  • :submit_time_before (Time, DateTime, Date, Integer, String) —

    Specify a time to filter for batch inference jobs that were submitted before the time you specify.

  • :status_equals (String) —

    Specify a status to filter for batch inference jobs whose statuses match the string you specify.

    The following statuses are possible:

    • Submitted – This job has been submitted to a queue for validation.

    • Validating – This job is being validated for the requirements described in [Format and upload your batch inference data]. The criteria include the following:

      • Your IAM service role has access to the Amazon S3 buckets containing your files.

      • Your files are .jsonl files and each individual record is a JSON object in the correct format. Note that validation doesn’t check if the ‘modelInput` value matches the request body for the model.

      • Your files fulfill the requirements for file size and number of records. For more information, see [Quotas for Amazon Bedrock].

    • Scheduled – This job has been validated and is now in a queue. The job will automatically start when it reaches its turn.

    • Expired – This job timed out because it was scheduled but didn’t begin before the set timeout duration. Submit a new job request.

    • InProgress – This job has begun. You can start viewing the results in the output S3 location.

    • Completed – This job has successfully completed. View the output files in the output S3 location.

    • PartiallyCompleted – This job has partially completed. Not all of your records could be processed in time. View the output files in the output S3 location.

    • Failed – This job has failed. Check the failure message for any further details. For further assistance, reach out to the [Amazon Web Services Support Center].

    • Stopped – This job was stopped by a user.

    • Stopping – This job is being stopped by a user.

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/batch-inference-data.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/quotas.html [3]: console.aws.amazon.com/support/home/

  • :name_contains (String) —

    Specify a string to filter for batch inference jobs whose names contain the string.

  • :max_results (Integer) —

    The maximum number of results to return. If there are more results than the number that you specify, a ‘nextToken` value is returned. Use the `nextToken` in a request to return the next batch of results.

  • :next_token (String) —

    If there were more results than the value you specified in the ‘maxResults` field in a previous `ListModelInvocationJobs` request, the response would have returned a `nextToken` value. To see the next batch of results, send the `nextToken` value in another request.

  • :sort_by (String) —

    An attribute by which to sort the results.

  • :sort_order (String) —

    Specifies whether to sort the results by ascending or descending order.

Returns:

See Also:



6802
6803
6804
6805
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6802

def list_model_invocation_jobs(params = {}, options = {})
  req = build_request(:list_model_invocation_jobs, params)
  req.send_request(options)
end

#list_prompt_routers(params = {}) ⇒ Types::ListPromptRoutersResponse

Retrieves a list of prompt routers.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_prompt_routers({
  max_results: 1,
  next_token: "PaginationToken",
  type: "custom", # accepts custom, default
})

Response structure


resp.prompt_router_summaries #=> Array
resp.prompt_router_summaries[0].prompt_router_name #=> String
resp.prompt_router_summaries[0].routing_criteria.response_quality_difference #=> Float
resp.prompt_router_summaries[0].description #=> String
resp.prompt_router_summaries[0].created_at #=> Time
resp.prompt_router_summaries[0].updated_at #=> Time
resp.prompt_router_summaries[0].prompt_router_arn #=> String
resp.prompt_router_summaries[0].models #=> Array
resp.prompt_router_summaries[0].models[0].model_arn #=> String
resp.prompt_router_summaries[0].fallback_model.model_arn #=> String
resp.prompt_router_summaries[0].status #=> String, one of "AVAILABLE"
resp.prompt_router_summaries[0].type #=> String, one of "custom", "default"
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of prompt routers to return in one page of results.

  • :next_token (String) —

    Specify the pagination token from a previous request to retrieve the next page of results.

  • :type (String) —

    The type of the prompt routers, such as whether it’s default or custom.

Returns:

See Also:



6855
6856
6857
6858
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6855

def list_prompt_routers(params = {}, options = {})
  req = build_request(:list_prompt_routers, params)
  req.send_request(options)
end

#list_provisioned_model_throughputs(params = {}) ⇒ Types::ListProvisionedModelThroughputsResponse

Lists the Provisioned Throughputs in the account. For more information, see [Provisioned Throughput] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_provisioned_model_throughputs({
  creation_time_after: Time.now,
  creation_time_before: Time.now,
  status_equals: "Creating", # accepts Creating, InService, Updating, Failed
  model_arn_equals: "ModelArn",
  name_contains: "ProvisionedModelName",
  max_results: 1,
  next_token: "PaginationToken",
  sort_by: "CreationTime", # accepts CreationTime
  sort_order: "Ascending", # accepts Ascending, Descending
})

Response structure


resp.next_token #=> String
resp.provisioned_model_summaries #=> Array
resp.provisioned_model_summaries[0].provisioned_model_name #=> String
resp.provisioned_model_summaries[0].provisioned_model_arn #=> String
resp.provisioned_model_summaries[0].model_arn #=> String
resp.provisioned_model_summaries[0].desired_model_arn #=> String
resp.provisioned_model_summaries[0].foundation_model_arn #=> String
resp.provisioned_model_summaries[0].model_units #=> Integer
resp.provisioned_model_summaries[0].desired_model_units #=> Integer
resp.provisioned_model_summaries[0].status #=> String, one of "Creating", "InService", "Updating", "Failed"
resp.provisioned_model_summaries[0].commitment_duration #=> String, one of "OneMonth", "SixMonths"
resp.provisioned_model_summaries[0].commitment_expiration_time #=> Time
resp.provisioned_model_summaries[0].creation_time #=> Time
resp.provisioned_model_summaries[0].last_modified_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :creation_time_after (Time, DateTime, Date, Integer, String) —

    A filter that returns Provisioned Throughputs created after the specified time.

  • :creation_time_before (Time, DateTime, Date, Integer, String) —

    A filter that returns Provisioned Throughputs created before the specified time.

  • :status_equals (String) —

    A filter that returns Provisioned Throughputs if their statuses matches the value that you specify.

  • :model_arn_equals (String) —

    A filter that returns Provisioned Throughputs whose model Amazon Resource Name (ARN) is equal to the value that you specify.

  • :name_contains (String) —

    A filter that returns Provisioned Throughputs if their name contains the expression that you specify.

  • :max_results (Integer) —

    THe maximum number of results to return in the response. If there are more results than the number you specified, the response returns a ‘nextToken` value. To see the next batch of results, send the `nextToken` value in another list request.

  • :next_token (String) —

    If there are more results than the number you specified in the ‘maxResults` field, the response returns a `nextToken` value. To see the next batch of results, specify the `nextToken` value in this field.

  • :sort_by (String) —

    The field by which to sort the returned list of Provisioned Throughputs.

  • :sort_order (String) —

    The sort order of the results.

Returns:

See Also:



6950
6951
6952
6953
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6950

def list_provisioned_model_throughputs(params = {}, options = {})
  req = build_request(:list_provisioned_model_throughputs, params)
  req.send_request(options)
end

#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceResponse

List the tags associated with the specified resource.

For more information, see [Tagging resources] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.list_tags_for_resource({
  resource_arn: "TaggableResourcesArn", # required
})

Response structure


resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the resource.

Returns:

See Also:



6987
6988
6989
6990
 
# File 'lib/aws-sdk-bedrock/client.rb', line 6987

def list_tags_for_resource(params = {}, options = {})
  req = build_request(:list_tags_for_resource, params)
  req.send_request(options)
end

#put_enforced_guardrail_configuration(params = {}) ⇒ Types::PutEnforcedGuardrailConfigurationResponse

Sets the account-level enforced guardrail configuration.

Examples:

Request syntax with placeholder values


resp = client.put_enforced_guardrail_configuration({
  config_id: "AccountEnforcedGuardrailConfigurationId",
  guardrail_inference_config: { # required
    guardrail_identifier: "GuardrailIdentifier", # required
    guardrail_version: "GuardrailNumericalVersion", # required
    selective_content_guarding: {
      system: "SELECTIVE", # accepts SELECTIVE, COMPREHENSIVE
      messages: "SELECTIVE", # accepts SELECTIVE, COMPREHENSIVE
    },
    model_enforcement: {
      included_models: ["IncludedModelId"], # required
      excluded_models: ["ExcludedModelId"], # required
    },
  },
})

Response structure


resp.config_id #=> String
resp.updated_at #=> Time
resp.updated_by #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



7034
7035
7036
7037
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7034

def put_enforced_guardrail_configuration(params = {}, options = {})
  req = build_request(:put_enforced_guardrail_configuration, params)
  req.send_request(options)
end

#put_model_invocation_logging_configuration(params = {}) ⇒ Struct

Set the configuration values for model invocation logging.

Examples:

Request syntax with placeholder values


resp = client.put_model_invocation_logging_configuration({
  logging_config: { # required
    cloud_watch_config: {
      log_group_name: "LogGroupName", # required
      role_arn: "RoleArn", # required
      large_data_delivery_s3_config: {
        bucket_name: "BucketName", # required
        key_prefix: "KeyPrefix",
      },
    },
    s3_config: {
      bucket_name: "BucketName", # required
      key_prefix: "KeyPrefix",
    },
    text_data_delivery_enabled: false,
    image_data_delivery_enabled: false,
    embedding_data_delivery_enabled: false,
    video_data_delivery_enabled: false,
    audio_data_delivery_enabled: false,
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



7074
7075
7076
7077
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7074

def put_model_invocation_logging_configuration(params = {}, options = {})
  req = build_request(:put_model_invocation_logging_configuration, params)
  req.send_request(options)
end

#put_resource_policy(params = {}) ⇒ Types::PutResourcePolicyResponse

Adds a resource policy for a Bedrock resource.

Examples:

Request syntax with placeholder values


resp = client.put_resource_policy({
  resource_arn: "ResourcePolicyResourceArn", # required
  resource_policy: "ResourcePolicyDocument", # required
})

Response structure


resp.resource_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The ARN of the Bedrock resource to which this resource policy applies.

  • :resource_policy (required, String) —

    The JSON string representing the Bedrock resource policy.

Returns:

See Also:



7106
7107
7108
7109
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7106

def put_resource_policy(params = {}, options = {})
  req = build_request(:put_resource_policy, params)
  req.send_request(options)
end

#put_use_case_for_model_access(params = {}) ⇒ Struct

Put usecase for model access.

Examples:

Request syntax with placeholder values


resp = client.put_use_case_for_model_access({
  form_data: "data", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :form_data (required, String, StringIO, File) —

    Put customer profile Request.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



7128
7129
7130
7131
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7128

def put_use_case_for_model_access(params = {}, options = {})
  req = build_request(:put_use_case_for_model_access, params)
  req.send_request(options)
end

#register_marketplace_model_endpoint(params = {}) ⇒ Types::RegisterMarketplaceModelEndpointResponse

Registers an existing Amazon SageMaker endpoint with Amazon Bedrock Marketplace, allowing it to be used with Amazon Bedrock APIs.

Examples:

Request syntax with placeholder values


resp = client.register_marketplace_model_endpoint({
  endpoint_identifier: "Arn", # required
  model_source_identifier: "ModelSourceIdentifier", # required
})

Response structure


resp.marketplace_model_endpoint.endpoint_arn #=> String
resp.marketplace_model_endpoint.model_source_identifier #=> String
resp.marketplace_model_endpoint.status #=> String, one of "REGISTERED", "INCOMPATIBLE_ENDPOINT"
resp.marketplace_model_endpoint.status_message #=> String
resp.marketplace_model_endpoint.created_at #=> Time
resp.marketplace_model_endpoint.updated_at #=> Time
resp.marketplace_model_endpoint.endpoint_config.sage_maker.initial_instance_count #=> Integer
resp.marketplace_model_endpoint.endpoint_config.sage_maker.instance_type #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.execution_role #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.kms_encryption_key #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.subnet_ids #=> Array
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.subnet_ids[0] #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.security_group_ids #=> Array
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.security_group_ids[0] #=> String
resp.marketplace_model_endpoint.endpoint_status #=> String
resp.marketplace_model_endpoint.endpoint_status_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :endpoint_identifier (required, String) —

    The ARN of the Amazon SageMaker endpoint you want to register with Amazon Bedrock Marketplace.

  • :model_source_identifier (required, String) —

    The ARN of the model from Amazon Bedrock Marketplace that is deployed on the endpoint.

Returns:

See Also:



7178
7179
7180
7181
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7178

def register_marketplace_model_endpoint(params = {}, options = {})
  req = build_request(:register_marketplace_model_endpoint, params)
  req.send_request(options)
end

#start_automated_reasoning_policy_build_workflow(params = {}) ⇒ Types::StartAutomatedReasoningPolicyBuildWorkflowResponse

Starts a new build workflow for an Automated Reasoning policy. This initiates the process of analyzing source documents and generating policy rules, variables, and types.

Examples:

Request syntax with placeholder values


resp = client.start_automated_reasoning_policy_build_workflow({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_type: "INGEST_CONTENT", # required, accepts INGEST_CONTENT, REFINE_POLICY, IMPORT_POLICY, GENERATE_FIDELITY_REPORT, GENERATE_POLICY_SCENARIOS
  client_request_token: "IdempotencyToken",
  source_content: { # required
    policy_definition: {
      version: "AutomatedReasoningPolicyFormatVersion",
      types: [
        {
          name: "AutomatedReasoningPolicyDefinitionTypeName", # required
          description: "AutomatedReasoningPolicyDefinitionTypeDescription",
          values: [ # required
            {
              value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
              description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
            },
          ],
        },
      ],
      rules: [
        {
          id: "AutomatedReasoningPolicyDefinitionRuleId", # required
          expression: "AutomatedReasoningPolicyDefinitionRuleExpression", # required
          alternate_expression: "AutomatedReasoningPolicyDefinitionRuleAlternateExpression",
        },
      ],
      variables: [
        {
          name: "AutomatedReasoningPolicyDefinitionVariableName", # required
          type: "AutomatedReasoningPolicyDefinitionTypeName", # required
          description: "AutomatedReasoningPolicyDefinitionVariableDescription", # required
        },
      ],
    },
    workflow_content: {
      documents: [
        {
          document: "data", # required
          document_content_type: "pdf", # required, accepts pdf, txt
          document_name: "AutomatedReasoningPolicyBuildDocumentName", # required
          document_description: "AutomatedReasoningPolicyBuildDocumentDescription",
        },
      ],
      policy_repair_assets: {
        annotations: [ # required
          {
            add_type: {
              name: "AutomatedReasoningPolicyDefinitionTypeName", # required
              description: "AutomatedReasoningPolicyDefinitionTypeDescription", # required
              values: [ # required
                {
                  value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
                  description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
                },
              ],
            },
            update_type: {
              name: "AutomatedReasoningPolicyDefinitionTypeName", # required
              new_name: "AutomatedReasoningPolicyDefinitionTypeName",
              description: "AutomatedReasoningPolicyDefinitionTypeDescription",
              values: [ # required
                {
                  add_type_value: {
                    value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
                    description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
                  },
                  update_type_value: {
                    value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
                    new_value: "AutomatedReasoningPolicyDefinitionTypeValueName",
                    description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
                  },
                  delete_type_value: {
                    value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
                  },
                },
              ],
            },
            delete_type: {
              name: "AutomatedReasoningPolicyDefinitionTypeName", # required
            },
            add_variable: {
              name: "AutomatedReasoningPolicyDefinitionVariableName", # required
              type: "AutomatedReasoningPolicyDefinitionTypeName", # required
              description: "AutomatedReasoningPolicyDefinitionVariableDescription", # required
            },
            update_variable: {
              name: "AutomatedReasoningPolicyDefinitionVariableName", # required
              new_name: "AutomatedReasoningPolicyDefinitionVariableName",
              description: "AutomatedReasoningPolicyDefinitionVariableDescription",
            },
            delete_variable: {
              name: "AutomatedReasoningPolicyDefinitionVariableName", # required
            },
            add_rule: {
              expression: "AutomatedReasoningPolicyDefinitionRuleExpression", # required
            },
            update_rule: {
              rule_id: "AutomatedReasoningPolicyDefinitionRuleId", # required
              expression: "AutomatedReasoningPolicyDefinitionRuleExpression", # required
            },
            delete_rule: {
              rule_id: "AutomatedReasoningPolicyDefinitionRuleId", # required
            },
            add_rule_from_natural_language: {
              natural_language: "AutomatedReasoningPolicyAnnotationRuleNaturalLanguage", # required
            },
            update_from_rules_feedback: {
              rule_ids: ["AutomatedReasoningPolicyDefinitionRuleId"],
              feedback: "AutomatedReasoningPolicyAnnotationFeedbackNaturalLanguage", # required
            },
            update_from_scenario_feedback: {
              rule_ids: ["AutomatedReasoningPolicyDefinitionRuleId"],
              scenario_expression: "AutomatedReasoningPolicyScenarioExpression", # required
              feedback: "AutomatedReasoningPolicyAnnotationFeedbackNaturalLanguage",
            },
            ingest_content: {
              content: "AutomatedReasoningPolicyAnnotationIngestContent", # required
            },
          },
        ],
      },
      generate_fidelity_report_content: {
        documents: [
          {
            document: "data", # required
            document_content_type: "pdf", # required, accepts pdf, txt
            document_name: "AutomatedReasoningPolicyBuildDocumentName", # required
            document_description: "AutomatedReasoningPolicyBuildDocumentDescription",
          },
        ],
      },
    },
  },
})

Response structure


resp.policy_arn #=> String
resp.build_workflow_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy for which to start the build workflow.

  • :build_workflow_type (required, String) —

    The type of build workflow to start (e.g., DOCUMENT_INGESTION for processing new documents, POLICY_REPAIR for fixing existing policies).

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the operation completes no more than once. If this token matches a previous request, Amazon Bedrock ignores the request but doesn’t return an error.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

  • :source_content (required, Types::AutomatedReasoningPolicyBuildWorkflowSource) —

    The source content for the build workflow, such as documents to analyze or repair instructions for existing policies.

Returns:

See Also:



7359
7360
7361
7362
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7359

def start_automated_reasoning_policy_build_workflow(params = {}, options = {})
  req = build_request(:start_automated_reasoning_policy_build_workflow, params)
  req.send_request(options)
end

#start_automated_reasoning_policy_test_workflow(params = {}) ⇒ Types::StartAutomatedReasoningPolicyTestWorkflowResponse

Initiates a test workflow to validate Automated Reasoning policy tests. The workflow executes the specified tests against the policy and generates validation results.

Examples:

Request syntax with placeholder values


resp = client.start_automated_reasoning_policy_test_workflow({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
  test_case_ids: ["AutomatedReasoningPolicyTestCaseId"],
  client_request_token: "IdempotencyToken",
})

Response structure


resp.policy_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy to test.

  • :build_workflow_id (required, String) —

    The build workflow identifier. The build workflow must show a ‘COMPLETED` status before running tests.

  • :test_case_ids (Array<String>) —

    The list of test identifiers to run. If not provided, all tests for the policy are run.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request but doesn’t return an error.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



7410
7411
7412
7413
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7410

def start_automated_reasoning_policy_test_workflow(params = {}, options = {})
  req = build_request(:start_automated_reasoning_policy_test_workflow, params)
  req.send_request(options)
end

#stop_advanced_prompt_optimization_job(params = {}) ⇒ Struct

Stops an in-progress advanced prompt optimization job.

Examples:

Request syntax with placeholder values


resp = client.stop_advanced_prompt_optimization_job({
  job_identifier: "AdvancedPromptOptimizationJobIdentifier", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    ARN or ID of the advanced prompt optimization job to stop.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



7432
7433
7434
7435
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7432

def stop_advanced_prompt_optimization_job(params = {}, options = {})
  req = build_request(:stop_advanced_prompt_optimization_job, params)
  req.send_request(options)
end

#stop_evaluation_job(params = {}) ⇒ Struct

Stops an evaluation job that is current being created or running.

Examples:

Request syntax with placeholder values


resp = client.stop_evaluation_job({
  job_identifier: "EvaluationJobIdentifier", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    The Amazon Resource Name (ARN) of the evaluation job you want to stop.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



7454
7455
7456
7457
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7454

def stop_evaluation_job(params = {}, options = {})
  req = build_request(:stop_evaluation_job, params)
  req.send_request(options)
end

#stop_model_customization_job(params = {}) ⇒ Struct

Stops an active model customization job. For more information, see

Custom models][1

in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/custom-models.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.stop_model_customization_job({
  job_identifier: "ModelCustomizationJobIdentifier", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    Job identifier of the job to stop.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



7482
7483
7484
7485
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7482

def stop_model_customization_job(params = {}, options = {})
  req = build_request(:stop_model_customization_job, params)
  req.send_request(options)
end

#stop_model_invocation_job(params = {}) ⇒ Struct

Stops a batch inference job. You’re only charged for tokens that were already processed. For more information, see [Stop a batch inference job].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/batch-inference-stop.html

Examples:

Request syntax with placeholder values


resp = client.stop_model_invocation_job({
  job_identifier: "ModelInvocationJobIdentifier", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_identifier (required, String) —

    The Amazon Resource Name (ARN) of the batch inference job to stop.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



7510
7511
7512
7513
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7510

def stop_model_invocation_job(params = {}, options = {})
  req = build_request(:stop_model_invocation_job, params)
  req.send_request(options)
end

#tag_resource(params = {}) ⇒ Struct

Associate tags with a resource. For more information, see [Tagging resources] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.tag_resource({
  resource_arn: "TaggableResourcesArn", # required
  tags: [ # required
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the resource to tag.

  • :tags (required, Array<Types::Tag>) —

    Tags to associate with the resource.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



7546
7547
7548
7549
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7546

def tag_resource(params = {}, options = {})
  req = build_request(:tag_resource, params)
  req.send_request(options)
end

#untag_resource(params = {}) ⇒ Struct

Remove one or more tags from a resource. For more information, see

Tagging resources][1

in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.untag_resource({
  resource_arn: "TaggableResourcesArn", # required
  tag_keys: ["TagKey"], # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the resource to untag.

  • :tag_keys (required, Array<String>) —

    Tag keys of the tags to remove from the resource.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



7577
7578
7579
7580
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7577

def untag_resource(params = {}, options = {})
  req = build_request(:untag_resource, params)
  req.send_request(options)
end

#update_automated_reasoning_policy(params = {}) ⇒ Types::UpdateAutomatedReasoningPolicyResponse

Updates an existing Automated Reasoning policy with new rules, variables, or configuration. This creates a new version of the policy while preserving the previous version.

Examples:

Request syntax with placeholder values


resp = client.update_automated_reasoning_policy({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  policy_definition: { # required
    version: "AutomatedReasoningPolicyFormatVersion",
    types: [
      {
        name: "AutomatedReasoningPolicyDefinitionTypeName", # required
        description: "AutomatedReasoningPolicyDefinitionTypeDescription",
        values: [ # required
          {
            value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
            description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
          },
        ],
      },
    ],
    rules: [
      {
        id: "AutomatedReasoningPolicyDefinitionRuleId", # required
        expression: "AutomatedReasoningPolicyDefinitionRuleExpression", # required
        alternate_expression: "AutomatedReasoningPolicyDefinitionRuleAlternateExpression",
      },
    ],
    variables: [
      {
        name: "AutomatedReasoningPolicyDefinitionVariableName", # required
        type: "AutomatedReasoningPolicyDefinitionTypeName", # required
        description: "AutomatedReasoningPolicyDefinitionVariableDescription", # required
      },
    ],
  },
  name: "AutomatedReasoningPolicyName",
  description: "AutomatedReasoningPolicyDescription",
})

Response structure


resp.policy_arn #=> String
resp.name #=> String
resp.definition_hash #=> String
resp.updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy to update. This must be the ARN of a draft policy.

  • :policy_definition (required, Types::AutomatedReasoningPolicyDefinition) —

    The updated policy definition containing the formal logic rules, variables, and types.

  • :name (String) —

    The updated name for the Automated Reasoning policy.

  • :description (String) —

    The updated description for the Automated Reasoning policy.

Returns:

See Also:



7655
7656
7657
7658
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7655

def update_automated_reasoning_policy(params = {}, options = {})
  req = build_request(:update_automated_reasoning_policy, params)
  req.send_request(options)
end

#update_automated_reasoning_policy_annotations(params = {}) ⇒ Types::UpdateAutomatedReasoningPolicyAnnotationsResponse

Updates the annotations for an Automated Reasoning policy build workflow. This allows you to modify extracted rules, variables, and types before finalizing the policy.

Examples:

Request syntax with placeholder values


resp = client.update_automated_reasoning_policy_annotations({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  build_workflow_id: "AutomatedReasoningPolicyBuildWorkflowId", # required
  annotations: [ # required
    {
      add_type: {
        name: "AutomatedReasoningPolicyDefinitionTypeName", # required
        description: "AutomatedReasoningPolicyDefinitionTypeDescription", # required
        values: [ # required
          {
            value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
            description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
          },
        ],
      },
      update_type: {
        name: "AutomatedReasoningPolicyDefinitionTypeName", # required
        new_name: "AutomatedReasoningPolicyDefinitionTypeName",
        description: "AutomatedReasoningPolicyDefinitionTypeDescription",
        values: [ # required
          {
            add_type_value: {
              value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
              description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
            },
            update_type_value: {
              value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
              new_value: "AutomatedReasoningPolicyDefinitionTypeValueName",
              description: "AutomatedReasoningPolicyDefinitionTypeValueDescription",
            },
            delete_type_value: {
              value: "AutomatedReasoningPolicyDefinitionTypeValueName", # required
            },
          },
        ],
      },
      delete_type: {
        name: "AutomatedReasoningPolicyDefinitionTypeName", # required
      },
      add_variable: {
        name: "AutomatedReasoningPolicyDefinitionVariableName", # required
        type: "AutomatedReasoningPolicyDefinitionTypeName", # required
        description: "AutomatedReasoningPolicyDefinitionVariableDescription", # required
      },
      update_variable: {
        name: "AutomatedReasoningPolicyDefinitionVariableName", # required
        new_name: "AutomatedReasoningPolicyDefinitionVariableName",
        description: "AutomatedReasoningPolicyDefinitionVariableDescription",
      },
      delete_variable: {
        name: "AutomatedReasoningPolicyDefinitionVariableName", # required
      },
      add_rule: {
        expression: "AutomatedReasoningPolicyDefinitionRuleExpression", # required
      },
      update_rule: {
        rule_id: "AutomatedReasoningPolicyDefinitionRuleId", # required
        expression: "AutomatedReasoningPolicyDefinitionRuleExpression", # required
      },
      delete_rule: {
        rule_id: "AutomatedReasoningPolicyDefinitionRuleId", # required
      },
      add_rule_from_natural_language: {
        natural_language: "AutomatedReasoningPolicyAnnotationRuleNaturalLanguage", # required
      },
      update_from_rules_feedback: {
        rule_ids: ["AutomatedReasoningPolicyDefinitionRuleId"],
        feedback: "AutomatedReasoningPolicyAnnotationFeedbackNaturalLanguage", # required
      },
      update_from_scenario_feedback: {
        rule_ids: ["AutomatedReasoningPolicyDefinitionRuleId"],
        scenario_expression: "AutomatedReasoningPolicyScenarioExpression", # required
        feedback: "AutomatedReasoningPolicyAnnotationFeedbackNaturalLanguage",
      },
      ingest_content: {
        content: "AutomatedReasoningPolicyAnnotationIngestContent", # required
      },
    },
  ],
  last_updated_annotation_set_hash: "AutomatedReasoningPolicyHash", # required
})

Response structure


resp.policy_arn #=> String
resp.build_workflow_id #=> String
resp.annotation_set_hash #=> String
resp.updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy whose annotations you want to update.

  • :build_workflow_id (required, String) —

    The unique identifier of the build workflow whose annotations you want to update.

  • :annotations (required, Array<Types::AutomatedReasoningPolicyAnnotation>) —

    The updated annotations containing modified rules, variables, and types for the policy.

  • :last_updated_annotation_set_hash (required, String) —

    The hash value of the annotation set that you’re updating. This is used for optimistic concurrency control to prevent conflicting updates.

Returns:

See Also:



7783
7784
7785
7786
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7783

def update_automated_reasoning_policy_annotations(params = {}, options = {})
  req = build_request(:update_automated_reasoning_policy_annotations, params)
  req.send_request(options)
end

#update_automated_reasoning_policy_test_case(params = {}) ⇒ Types::UpdateAutomatedReasoningPolicyTestCaseResponse

Updates an existing Automated Reasoning policy test. You can modify the content, query, expected result, and confidence threshold.

Examples:

Request syntax with placeholder values


resp = client.update_automated_reasoning_policy_test_case({
  policy_arn: "AutomatedReasoningPolicyArn", # required
  test_case_id: "AutomatedReasoningPolicyTestCaseId", # required
  guard_content: "AutomatedReasoningPolicyTestGuardContent", # required
  query_content: "AutomatedReasoningPolicyTestQueryContent",
  last_updated_at: Time.now, # required
  expected_aggregated_findings_result: "VALID", # required, accepts VALID, INVALID, SATISFIABLE, IMPOSSIBLE, TRANSLATION_AMBIGUOUS, TOO_COMPLEX, NO_TRANSLATION
  confidence_threshold: 1.0,
  client_request_token: "IdempotencyToken",
})

Response structure


resp.policy_arn #=> String
resp.test_case_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the Automated Reasoning policy that contains the test.

  • :test_case_id (required, String) —

    The unique identifier of the test to update.

  • :guard_content (required, String) —

    The updated content to be validated by the Automated Reasoning policy.

  • :query_content (String) —

    The updated input query or prompt that generated the content.

  • :last_updated_at (required, Time, DateTime, Date, Integer, String) —

    The timestamp when the test was last updated. This is used as a concurrency token to prevent conflicting modifications.

  • :expected_aggregated_findings_result (required, String) —

    The updated expected result of the Automated Reasoning check.

  • :confidence_threshold (Float) —

    The updated minimum confidence level for logic validation. If null is provided, the threshold will be removed.

  • :client_request_token (String) —

    A unique, case-sensitive identifier to ensure that the operation completes no more than one time. If this token matches a previous request, Amazon Bedrock ignores the request, but does not return an error.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



7851
7852
7853
7854
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7851

def update_automated_reasoning_policy_test_case(params = {}, options = {})
  req = build_request(:update_automated_reasoning_policy_test_case, params)
  req.send_request(options)
end

#update_custom_model_deployment(params = {}) ⇒ Types::UpdateCustomModelDeploymentResponse

Updates a custom model deployment with a new custom model. This allows you to deploy updated models without creating new deployment endpoints.

Examples:

Request syntax with placeholder values


resp = client.update_custom_model_deployment({
  model_arn: "CustomModelArn", # required
  custom_model_deployment_identifier: "CustomModelDeploymentIdentifier", # required
})

Response structure


resp.custom_model_deployment_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :model_arn (required, String) —

    ARN of the new custom model to deploy. This replaces the currently deployed model.

  • :custom_model_deployment_identifier (required, String) —

    Identifier of the custom model deployment to update with the new custom model.

Returns:

See Also:



7887
7888
7889
7890
 
# File 'lib/aws-sdk-bedrock/client.rb', line 7887

def update_custom_model_deployment(params = {}, options = {})
  req = build_request(:update_custom_model_deployment, params)
  req.send_request(options)
end

#update_guardrail(params = {}) ⇒ Types::UpdateGuardrailResponse

Updates a guardrail with the values you specify.

  • Specify a ‘name` and optional `description`.

  • Specify messages for when the guardrail successfully blocks a prompt or a model response in the ‘blockedInputMessaging` and `blockedOutputsMessaging` fields.

  • Specify topics for the guardrail to deny in the ‘topicPolicyConfig` object. Each [GuardrailTopicConfig] object in the `topicsConfig` list pertains to one topic.

    • Give a ‘name` and `description` so that the guardrail can properly identify the topic.

    • Specify ‘DENY` in the `type` field.

    • (Optional) Provide up to five prompts that you would categorize as belonging to the topic in the ‘examples` list.

  • Specify filter strengths for the harmful categories defined in Amazon Bedrock in the ‘contentPolicyConfig` object. Each

    GuardrailContentFilterConfig][2

    object in the ‘filtersConfig` list

    pertains to a harmful category. For more information, see [Content filters]. For more information about the fields in a content filter, see [GuardrailContentFilterConfig].

    • Specify the category in the ‘type` field.

    • Specify the strength of the filter for prompts in the ‘inputStrength` field and for model responses in the `strength` field of the [GuardrailContentFilterConfig].

  • (Optional) For security, include the ARN of a KMS key in the ‘kmsKeyId` field.

[1]: docs.aws.amazon.com/bedrock/latest/APIReference/API_GuardrailTopicConfig.html [2]: docs.aws.amazon.com/bedrock/latest/APIReference/API_GuardrailContentFilterConfig.html [3]: docs.aws.amazon.com/bedrock/latest/userguide/guardrails-content-filters

Examples:

Request syntax with placeholder values


resp = client.update_guardrail({
  guardrail_identifier: "GuardrailIdentifier", # required
  name: "GuardrailName", # required
  description: "GuardrailDescription",
  topic_policy_config: {
    topics_config: [ # required
      {
        name: "GuardrailTopicName", # required
        definition: "GuardrailTopicDefinition", # required
        examples: ["GuardrailTopicExample"],
        type: "DENY", # required, accepts DENY
        input_action: "BLOCK", # accepts BLOCK, NONE
        output_action: "BLOCK", # accepts BLOCK, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
    tier_config: {
      tier_name: "CLASSIC", # required, accepts CLASSIC, STANDARD
    },
  },
  content_policy_config: {
    filters_config: [ # required
      {
        type: "SEXUAL", # required, accepts SEXUAL, VIOLENCE, HATE, INSULTS, MISCONDUCT, PROMPT_ATTACK
        input_strength: "NONE", # required, accepts NONE, LOW, MEDIUM, HIGH
        output_strength: "NONE", # required, accepts NONE, LOW, MEDIUM, HIGH
        input_modalities: ["TEXT"], # accepts TEXT, IMAGE
        output_modalities: ["TEXT"], # accepts TEXT, IMAGE
        input_action: "BLOCK", # accepts BLOCK, NONE
        output_action: "BLOCK", # accepts BLOCK, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
    tier_config: {
      tier_name: "CLASSIC", # required, accepts CLASSIC, STANDARD
    },
  },
  word_policy_config: {
    words_config: [
      {
        text: "GuardrailWordConfigTextString", # required
        input_action: "BLOCK", # accepts BLOCK, NONE
        output_action: "BLOCK", # accepts BLOCK, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
    managed_word_lists_config: [
      {
        type: "PROFANITY", # required, accepts PROFANITY
        input_action: "BLOCK", # accepts BLOCK, NONE
        output_action: "BLOCK", # accepts BLOCK, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
  },
  sensitive_information_policy_config: {
    pii_entities_config: [
      {
        type: "ADDRESS", # required, accepts ADDRESS, AGE, AWS_ACCESS_KEY, AWS_SECRET_KEY, CA_HEALTH_NUMBER, CA_SOCIAL_INSURANCE_NUMBER, CREDIT_DEBIT_CARD_CVV, CREDIT_DEBIT_CARD_EXPIRY, CREDIT_DEBIT_CARD_NUMBER, DRIVER_ID, EMAIL, INTERNATIONAL_BANK_ACCOUNT_NUMBER, IP_ADDRESS, LICENSE_PLATE, MAC_ADDRESS, NAME, PASSWORD, PHONE, PIN, SWIFT_CODE, UK_NATIONAL_HEALTH_SERVICE_NUMBER, UK_NATIONAL_INSURANCE_NUMBER, UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER, URL, USERNAME, US_BANK_ACCOUNT_NUMBER, US_BANK_ROUTING_NUMBER, US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER, US_PASSPORT_NUMBER, US_SOCIAL_SECURITY_NUMBER, VEHICLE_IDENTIFICATION_NUMBER
        action: "BLOCK", # required, accepts BLOCK, ANONYMIZE, NONE
        input_action: "BLOCK", # accepts BLOCK, ANONYMIZE, NONE
        output_action: "BLOCK", # accepts BLOCK, ANONYMIZE, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
    regexes_config: [
      {
        name: "GuardrailRegexConfigNameString", # required
        description: "GuardrailRegexConfigDescriptionString",
        pattern: "GuardrailRegexConfigPatternString", # required
        action: "BLOCK", # required, accepts BLOCK, ANONYMIZE, NONE
        input_action: "BLOCK", # accepts BLOCK, ANONYMIZE, NONE
        output_action: "BLOCK", # accepts BLOCK, ANONYMIZE, NONE
        input_enabled: false,
        output_enabled: false,
      },
    ],
  },
  contextual_grounding_policy_config: {
    filters_config: [ # required
      {
        type: "GROUNDING", # required, accepts GROUNDING, RELEVANCE
        threshold: 1.0, # required
        action: "BLOCK", # accepts BLOCK, NONE
        enabled: false,
      },
    ],
  },
  automated_reasoning_policy_config: {
    policies: ["AutomatedReasoningPolicyArn"], # required
    confidence_threshold: 1.0,
  },
  cross_region_config: {
    guardrail_profile_identifier: "GuardrailCrossRegionGuardrailProfileIdentifier", # required
  },
  blocked_input_messaging: "GuardrailBlockedMessaging", # required
  blocked_outputs_messaging: "GuardrailBlockedMessaging", # required
  kms_key_id: "KmsKeyId",
})

Response structure


resp.guardrail_id #=> String
resp.guardrail_arn #=> String
resp.version #=> String
resp.updated_at #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :guardrail_identifier (required, String) —

    The unique identifier of the guardrail. This can be an ID or the ARN.

  • :name (required, String) —

    A name for the guardrail.

  • :description (String) —

    A description of the guardrail.

  • :topic_policy_config (Types::GuardrailTopicPolicyConfig) —

    The topic policy to configure for the guardrail.

  • :content_policy_config (Types::GuardrailContentPolicyConfig) —

    The content policy to configure for the guardrail.

  • :word_policy_config (Types::GuardrailWordPolicyConfig) —

    The word policy to configure for the guardrail.

  • :sensitive_information_policy_config (Types::GuardrailSensitiveInformationPolicyConfig) —

    The sensitive information policy to configure for the guardrail.

  • :contextual_grounding_policy_config (Types::GuardrailContextualGroundingPolicyConfig) —

    The contextual grounding policy configuration used to update a guardrail.

  • :automated_reasoning_policy_config (Types::GuardrailAutomatedReasoningPolicyConfig) —

    Updated configuration for Automated Reasoning policies associated with the guardrail.

  • :cross_region_config (Types::GuardrailCrossRegionConfig) —

    The system-defined guardrail profile that you’re using with your guardrail. Guardrail profiles define the destination Amazon Web Services Regions where guardrail inference requests can be automatically routed.

    For more information, see the [Amazon Bedrock User Guide].

    [1]: docs.aws.amazon.com/bedrock/latest/userguide/guardrails-cross-region.html

  • :blocked_input_messaging (required, String) —

    The message to return when the guardrail blocks a prompt.

  • :blocked_outputs_messaging (required, String) —

    The message to return when the guardrail blocks a model response.

  • :kms_key_id (String) —

    The ARN of the KMS key with which to encrypt the guardrail.

Returns:

See Also:



8107
8108
8109
8110
 
# File 'lib/aws-sdk-bedrock/client.rb', line 8107

def update_guardrail(params = {}, options = {})
  req = build_request(:update_guardrail, params)
  req.send_request(options)
end

#update_marketplace_model_endpoint(params = {}) ⇒ Types::UpdateMarketplaceModelEndpointResponse

Updates the configuration of an existing endpoint for a model from Amazon Bedrock Marketplace.

Examples:

Request syntax with placeholder values


resp = client.update_marketplace_model_endpoint({
  endpoint_arn: "Arn", # required
  endpoint_config: { # required
    sage_maker: {
      initial_instance_count: 1, # required
      instance_type: "InstanceType", # required
      execution_role: "RoleArn", # required
      kms_encryption_key: "KmsKeyId",
      vpc: {
        subnet_ids: ["SubnetId"], # required
        security_group_ids: ["SecurityGroupId"], # required
      },
    },
  },
  client_request_token: "IdempotencyToken",
})

Response structure


resp.marketplace_model_endpoint.endpoint_arn #=> String
resp.marketplace_model_endpoint.model_source_identifier #=> String
resp.marketplace_model_endpoint.status #=> String, one of "REGISTERED", "INCOMPATIBLE_ENDPOINT"
resp.marketplace_model_endpoint.status_message #=> String
resp.marketplace_model_endpoint.created_at #=> Time
resp.marketplace_model_endpoint.updated_at #=> Time
resp.marketplace_model_endpoint.endpoint_config.sage_maker.initial_instance_count #=> Integer
resp.marketplace_model_endpoint.endpoint_config.sage_maker.instance_type #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.execution_role #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.kms_encryption_key #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.subnet_ids #=> Array
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.subnet_ids[0] #=> String
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.security_group_ids #=> Array
resp.marketplace_model_endpoint.endpoint_config.sage_maker.vpc.security_group_ids[0] #=> String
resp.marketplace_model_endpoint.endpoint_status #=> String
resp.marketplace_model_endpoint.endpoint_status_message #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :endpoint_arn (required, String) —

    The Amazon Resource Name (ARN) of the endpoint you want to update.

  • :endpoint_config (required, Types::EndpointConfig) —

    The new configuration for the endpoint, including the number and type of instances to use.

  • :client_request_token (String) —

    A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. This token is listed as not required because Amazon Web Services SDKs automatically generate it for you and set this parameter. If you’re not using the Amazon Web Services SDK or the CLI, you must provide this token or the action will fail.

    **A suitable default value is auto-generated.** You should normally not need to pass this option.**

Returns:

See Also:



8178
8179
8180
8181
 
# File 'lib/aws-sdk-bedrock/client.rb', line 8178

def update_marketplace_model_endpoint(params = {}, options = {})
  req = build_request(:update_marketplace_model_endpoint, params)
  req.send_request(options)
end

#update_provisioned_model_throughput(params = {}) ⇒ Struct

Updates the name or associated model for a Provisioned Throughput. For more information, see [Provisioned Throughput] in the [Amazon Bedrock User Guide].

[1]: docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html [2]: docs.aws.amazon.com/bedrock/latest/userguide/what-is-service.html

Examples:

Request syntax with placeholder values


resp = client.update_provisioned_model_throughput({
  provisioned_model_id: "ProvisionedModelId", # required
  desired_provisioned_model_name: "ProvisionedModelName",
  desired_model_id: "ModelIdentifier",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :provisioned_model_id (required, String) —

    The Amazon Resource Name (ARN) or name of the Provisioned Throughput to update.

  • :desired_provisioned_model_name (String) —

    The new name for this Provisioned Throughput.

  • :desired_model_id (String) —

    The Amazon Resource Name (ARN) of the new model to associate with this Provisioned Throughput. You can’t specify this field if this Provisioned Throughput is associated with a base model.

    If this Provisioned Throughput is associated with a custom model, you can specify one of the following options:

    • The base model from which the custom model was customized.

    • Another custom model that was customized from the same base model as the custom model.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



8226
8227
8228
8229
 
# File 'lib/aws-sdk-bedrock/client.rb', line 8226

def update_provisioned_model_throughput(params = {}, options = {})
  req = build_request(:update_provisioned_model_throughput, params)
  req.send_request(options)
end

#waiter_names ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated. 


8255
8256
8257
 
# File 'lib/aws-sdk-bedrock/client.rb', line 8255

def waiter_names
  []
end