AWS.BedrockDataAutomation reference

Blueprint

Source: src/AWS/BedrockDataAutomation/Blueprint.ts

An Amazon Bedrock Data Automation Blueprint — a JSON schema describing the custom output fields to extract from documents, images, audio, or video. Attach blueprints to a DataAutomationProject via its customOutputConfiguration.

Blueprint: Creating Blueprints

Document blueprint with custom fields

import * as BDA from "alchemy/AWS/BedrockDataAutomation";

const blueprint = yield* BDA.Blueprint("InvoiceBlueprint", {
  type: "DOCUMENT",
  schema: JSON.stringify({
    $schema: "http://json-schema.org/draft-07/schema#",
    description: "Extract invoice fields",
    class: "invoice",
    type: "object",
    properties: {
      invoice_number: {
        type: "string",
        inferenceType: "explicit",
        instruction: "The invoice number",
      },
    },
  }),
});

Attach a blueprint to a project

const project = yield* BDA.DataAutomationProject("Docs", {
  standardOutputConfiguration: {},
  customOutputConfiguration: {
    blueprints: [{ blueprintArn: blueprint.blueprintArn }],
  },
});

CopyBlueprintStage

Source: src/AWS/BedrockDataAutomation/CopyBlueprintStage.ts

Runtime binding for the CopyBlueprintStage operation (IAM action bedrock:CopyBlueprintStage on the blueprint ARN) — copy the bound blueprint between its DEVELOPMENT and LIVE stages from a deployed Function (e.g. promote a tuned development schema to live).

Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.CopyBlueprintStageHttp).

CopyBlueprintStage: Blueprint Management

// deploy time — bind the blueprint
const copyStage =
  yield* AWS.BedrockDataAutomation.CopyBlueprintStage(blueprint);

// runtime — promote the development copy
yield* copyStage({ sourceStage: "DEVELOPMENT", targetStage: "LIVE" });

CreateBlueprintVersion

Source: src/AWS/BedrockDataAutomation/CreateBlueprintVersion.ts

Runtime binding for the CreateBlueprintVersion operation (IAM action bedrock:CreateBlueprintVersion on the blueprint ARN) — snapshot the bound blueprint’s current schema as an immutable version from a deployed Function.

Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.CreateBlueprintVersionHttp).

CreateBlueprintVersion: Blueprint Management

// deploy time — bind the blueprint
const createVersion =
  yield* AWS.BedrockDataAutomation.CreateBlueprintVersion(blueprint);

// runtime — freeze the current schema as a new version
const { blueprint: version } = yield* createVersion({});
yield* Effect.log(`created version ${version.blueprintVersion}`);

DataAutomationLibrary

Source: src/AWS/BedrockDataAutomation/DataAutomationLibrary.ts

An Amazon Bedrock Data Automation Library — a store of reusable entities (currently VOCABULARY entities: domain phrases with display forms) that data automation projects reference via their dataAutomationLibraryConfiguration to improve extraction accuracy.

Entities are loaded into the library with ingestion jobs — see the InvokeDataAutomationLibraryIngestionJob binding.

DataAutomationLibrary: Creating Libraries

Library with a description

import * as BDA from "alchemy/AWS/BedrockDataAutomation";

const library = yield* BDA.DataAutomationLibrary("Vocab", {
  libraryDescription: "domain vocabulary for invoice extraction",
});

Reference the library from a project

const project = yield* BDA.DataAutomationProject("Docs", {
  standardOutputConfiguration: {},
  dataAutomationLibraryConfiguration: {
    libraries: [{ libraryArn: library.libraryArn }],
  },
});

DataAutomationProject

Source: src/AWS/BedrockDataAutomation/DataAutomationProject.ts

An Amazon Bedrock Data Automation Project — the configuration unit that turns documents, images, audio, and video into structured output, with optional custom output driven by Blueprints.

DataAutomationProject: Creating Projects

Project with default standard output

import * as BDA from "alchemy/AWS/BedrockDataAutomation";

const project = yield* BDA.DataAutomationProject("Docs", {
  standardOutputConfiguration: {},
});

Document project with granular extraction

const project = yield* BDA.DataAutomationProject("Docs", {
  projectDescription: "invoice pipeline",
  standardOutputConfiguration: {
    document: {
      extraction: {
        granularity: { types: ["DOCUMENT", "PAGE"] },
        boundingBox: { state: "DISABLED" },
      },
      generativeField: { state: "DISABLED" },
      outputFormat: {
        textFormat: { types: ["MARKDOWN"] },
        additionalFileFormat: { state: "DISABLED" },
      },
    },
  },
});

DataAutomationProject: Custom Output

const blueprint = yield* BDA.Blueprint("InvoiceBlueprint", {
  type: "DOCUMENT",
  schema: invoiceSchemaJson,
});

const project = yield* BDA.DataAutomationProject("Docs", {
  standardOutputConfiguration: {},
  customOutputConfiguration: {
    blueprints: [{ blueprintArn: blueprint.blueprintArn }],
  },
});

GetBlueprintOptimizationStatus

Source: src/AWS/BedrockDataAutomation/GetBlueprintOptimizationStatus.ts

Runtime binding for the GetBlueprintOptimizationStatus operation (IAM action bedrock:GetBlueprintOptimizationStatus on * — optimization invocation ARNs are minted at runtime) — poll the status of a blueprint optimization job started by InvokeBlueprintOptimizationAsync.

Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.GetBlueprintOptimizationStatusHttp).

GetBlueprintOptimizationStatus: Blueprint Optimization

// deploy time — account-level binding
const getStatus =
  yield* AWS.BedrockDataAutomation.GetBlueprintOptimizationStatus();

// runtime — poll the invocation returned by InvokeBlueprintOptimizationAsync
const { status, outputConfiguration } = yield* getStatus({ invocationArn });
if (status === "Success") {
  yield* Effect.log(
    `optimized schema at ${outputConfiguration?.s3Object.s3Uri}`,
  );
}

GetDataAutomationLibraryEntity

Source: src/AWS/BedrockDataAutomation/GetDataAutomationLibraryEntity.ts

Runtime binding for the GetDataAutomationLibraryEntity operation (IAM action bedrock:GetDataAutomationLibraryEntity on the library ARN) — read a single entity (e.g. a VOCABULARY entry with its phrases) from the bound library.

Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.GetDataAutomationLibraryEntityHttp).

GetDataAutomationLibraryEntity: Library Entities

// deploy time — bind the library
const getEntity =
  yield* AWS.BedrockDataAutomation.GetDataAutomationLibraryEntity(library);

// runtime — fetch the entity written by an ingestion job
const { entity } = yield* getEntity({
  entityType: "VOCABULARY",
  entityId,
});

GetDataAutomationLibraryIngestionJob

Source: src/AWS/BedrockDataAutomation/GetDataAutomationLibraryIngestionJob.ts

Runtime binding for the GetDataAutomationLibraryIngestionJob operation (IAM action bedrock:GetDataAutomationLibraryIngestionJob on the library ARN) — poll the status of a library ingestion job from a deployed Function.

Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.GetDataAutomationLibraryIngestionJobHttp).

GetDataAutomationLibraryIngestionJob: Library Ingestion

// deploy time — bind the library
const getJob =
  yield* AWS.BedrockDataAutomation.GetDataAutomationLibraryIngestionJob(library);

// runtime — check the job started by the ingestion binding
const { job } = yield* getJob({ jobArn });
if (job?.jobStatus === "COMPLETED") {
  yield* Effect.log(`ingestion results at ${job.outputConfiguration.s3Uri}`);
}

GetDataAutomationStatus

Source: src/AWS/BedrockDataAutomation/GetDataAutomationStatus.ts

Runtime binding for the GetDataAutomationStatus operation (IAM action bedrock:GetDataAutomationStatus on * — invocation ARNs are minted at runtime) — poll the status of an asynchronous Bedrock Data Automation job from a deployed Function.

Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.GetDataAutomationStatusHttp).

GetDataAutomationStatus: Polling Job Status

// deploy time — account-level binding
const getStatus = yield* AWS.BedrockDataAutomation.GetDataAutomationStatus();

// runtime — poll the invocation returned by InvokeDataAutomationAsync
const { status, outputConfiguration } = yield* getStatus({ invocationArn });
if (status === "Success") {
  yield* Effect.log(`results at ${outputConfiguration?.s3Uri}`);
}

InvokeBlueprintOptimizationAsync

Source: src/AWS/BedrockDataAutomation/InvokeBlueprintOptimizationAsync.ts

Runtime binding for the InvokeBlueprintOptimizationAsync operation (IAM action bedrock:InvokeBlueprintOptimizationAsync on the blueprint ARN + the account’s data automation profiles) — start an asynchronous job that tunes the bound blueprint’s schema against labeled samples (asset + ground-truth pairs in S3) from a deployed Function.

The samples and output location are read/written with the caller’s S3 permissions. Poll the returned invocation with the GetBlueprintOptimizationStatus binding. Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.InvokeBlueprintOptimizationAsyncHttp).

InvokeBlueprintOptimizationAsync: Blueprint Optimization

// deploy time — bind the blueprint
const optimize =
  yield* AWS.BedrockDataAutomation.InvokeBlueprintOptimizationAsync(blueprint);

// runtime — start the optimization job
const { invocationArn } = yield* optimize({
  samples: [
    {
      assetS3Object: { s3Uri: `s3://${bucket}/samples/invoice-1.pdf` },
      groundTruthS3Object: { s3Uri: `s3://${bucket}/samples/invoice-1.json` },
    },
  ],
  outputConfiguration: {
    s3Object: { s3Uri: `s3://${bucket}/optimization-results/` },
  },
  dataAutomationProfileArn: profileArn,
});

InvokeDataAutomation

Source: src/AWS/BedrockDataAutomation/InvokeDataAutomation.ts

Runtime binding for the synchronous InvokeDataAutomation operation (IAM action bedrock:InvokeDataAutomation on the project ARN + the account’s data automation profiles) — process a file inline against the bound project from a deployed Function and get the extracted output back in the response.

The bound DataAutomationProject must be created with projectType: "SYNC". Input can be passed inline as bytes or as an s3Uri; the caller supplies the cross-region data automation profile ARN (e.g. …:data-automation-profile/us.data-automation-v1). Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.InvokeDataAutomationHttp).

InvokeDataAutomation: Invoking Data Automation

// deploy time — bind the SYNC project
const invoke = yield* AWS.BedrockDataAutomation.InvokeDataAutomation(syncProject);

// runtime — process request bytes synchronously
const result = yield* invoke({
  inputConfiguration: { bytes: documentBytes },
  dataAutomationProfileArn: profileArn,
});
const fields = result.outputSegments?.[0]?.customOutput;

InvokeDataAutomationAsync

Source: src/AWS/BedrockDataAutomation/InvokeDataAutomationAsync.ts

Runtime binding for the InvokeDataAutomationAsync operation (IAM action bedrock:InvokeDataAutomationAsync on the project ARN + the account’s data automation profiles) — start an asynchronous Bedrock Data Automation job against the bound project from a deployed Function.

The binding is constructed with the target DataAutomationProject; its ARN and stage are injected into every runtime request as dataAutomationConfiguration. The caller supplies the S3 input/output locations and the cross-region data automation profile ARN (e.g. arn:aws:bedrock:us-west-2:{account}:data-automation-profile/us.data-automation-v1). The calling role also needs s3:GetObject on the input and s3:PutObject on the output location — Bedrock Data Automation accesses S3 with the caller’s permissions. Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.InvokeDataAutomationAsyncHttp).

InvokeDataAutomationAsync: Invoking Data Automation

Start An Async Job For An Uploaded Document

// deploy time — bind the project
const invokeAsync = yield* AWS.BedrockDataAutomation.InvokeDataAutomationAsync(project);

// runtime — process a document already in S3
const { invocationArn } = yield* invokeAsync({
  inputConfiguration: { s3Uri: `s3://${bucket}/uploads/invoice.pdf` },
  outputConfiguration: { s3Uri: `s3://${bucket}/results/` },
  dataAutomationProfileArn: profileArn,
});

Get Notified Via EventBridge When The Job Settles

yield* invokeAsync({
  inputConfiguration: { s3Uri: input },
  outputConfiguration: { s3Uri: output },
  dataAutomationProfileArn: profileArn,
  notificationConfiguration: {
    eventBridgeConfiguration: { eventBridgeEnabled: true },
  },
});
// pair with AWS.BedrockDataAutomation.consumeDataAutomationJobEvents

InvokeDataAutomationLibraryIngestionJob

Source: src/AWS/BedrockDataAutomation/InvokeDataAutomationLibraryIngestionJob.ts

Runtime binding for the InvokeDataAutomationLibraryIngestionJob operation (IAM action bedrock:InvokeDataAutomationLibraryIngestionJob on the library ARN) — start an asynchronous ingestion job that upserts or deletes entities in the bound library from a deployed Function.

Entities can be passed inline (inputConfiguration.inlinePayload) or as an S3 object; results are written to outputConfiguration.s3Uri with the caller’s S3 permissions. Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.InvokeDataAutomationLibraryIngestionJobHttp).

InvokeDataAutomationLibraryIngestionJob: Library Ingestion

// deploy time — bind the library
const ingest =
  yield* AWS.BedrockDataAutomation.InvokeDataAutomationLibraryIngestionJob(library);

// runtime — upsert one vocabulary entity
const { jobArn } = yield* ingest({
  entityType: "VOCABULARY",
  operationType: "UPSERT",
  inputConfiguration: {
    inlinePayload: {
      upsertEntitiesInfo: [
        {
          vocabulary: {
            language: "EN",
            phrases: [{ text: "Alchemy", displayAsText: "Alchemy" }],
          },
        },
      ],
    },
  },
  outputConfiguration: { s3Uri: `s3://${bucket}/library-results/` },
});

ListDataAutomationLibraryEntities

Source: src/AWS/BedrockDataAutomation/ListDataAutomationLibraryEntities.ts

Runtime binding for the ListDataAutomationLibraryEntities operation (IAM action bedrock:ListDataAutomationLibraryEntities on the library ARN) — page through the bound library’s entities of a given type from a deployed Function.

Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.ListDataAutomationLibraryEntitiesHttp).

ListDataAutomationLibraryEntities: Library Entities

// deploy time — bind the library
const listEntities =
  yield* AWS.BedrockDataAutomation.ListDataAutomationLibraryEntities(library);

// runtime — first page of vocabulary entities
const { entities } = yield* listEntities({
  entityType: "VOCABULARY",
  maxResults: 25,
});

ListDataAutomationLibraryIngestionJobs

Source: src/AWS/BedrockDataAutomation/ListDataAutomationLibraryIngestionJobs.ts

Runtime binding for the ListDataAutomationLibraryIngestionJobs operation (IAM action bedrock:ListDataAutomationLibraryIngestionJobs on the library ARN) — page through the bound library’s ingestion jobs from a deployed Function.

Provide the implementation with Effect.provide(AWS.BedrockDataAutomation.ListDataAutomationLibraryIngestionJobsHttp).

ListDataAutomationLibraryIngestionJobs: Library Ingestion

// deploy time — bind the library
const listJobs =
  yield* AWS.BedrockDataAutomation.ListDataAutomationLibraryIngestionJobs(library);

// runtime — first page of jobs
const { jobs } = yield* listJobs({ maxResults: 25 });