@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

package/lib/document-processing/bedrock-document-processing.d.ts

@@ -0,0 +1,167 @@
+import { Duration } from 'aws-cdk-lib';
+import { FoundationModelIdentifier } from 'aws-cdk-lib/aws-bedrock';
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { Function } from 'aws-cdk-lib/aws-lambda';
+import { StateMachine } from 'aws-cdk-lib/aws-stepfunctions';
+import { Construct } from 'constructs';
+import { BaseDocumentProcessing, BaseDocumentProcessingProps, DocumentProcessingStepType } from './base-document-processing';
+/**
+ * Configuration properties for BedrockDocumentProcessing construct.
+ * Extends BaseDocumentProcessingProps with Bedrock-specific options.
+ */
+export interface BedrockDocumentProcessingProps extends BaseDocumentProcessingProps {
+    /**
+     * Bedrock foundation model for document classification step.
+     * @default FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_7_SONNET_20250219_V1_0
+     */
+    readonly classificationModelId?: FoundationModelIdentifier;
+    /**
+     * Bedrock foundation model for document extraction step.
+     * @default FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_7_SONNET_20250219_V1_0
+     */
+    readonly processingModelId?: FoundationModelIdentifier;
+    /**
+     * Custom prompt template for document classification.
+     * Must include placeholder for document content.
+     * @default DEFAULT_CLASSIFICATION_PROMPT
+     */
+    readonly classificationPrompt?: string;
+    /**
+     * Custom prompt template for document extraction.
+     * Must include placeholder for document content and classification result.
+     * @default DEFAULT_EXTRACTION_PROMPT
+     */
+    readonly processingPrompt?: string;
+    /**
+     * Optional Lambda function for document enrichment step.
+     * If provided, will be invoked after extraction with workflow state.
+     */
+    readonly enrichmentLambdaFunction?: Function;
+    /**
+     * Optional Lambda function for post-processing step.
+     * If provided, will be invoked after enrichment with workflow state.
+     */
+    readonly postProcessingLambdaFunction?: Function;
+    /**
+     * Timeout for individual Step Functions tasks (classification, extraction, etc.).
+     * @default Duration.minutes(5)
+     */
+    readonly stepTimeouts?: Duration;
+    /**
+     * Enable cross-region inference for Bedrock models to improve availability and performance.
+     * When enabled, uses inference profiles instead of direct model invocation.
+     * @default false
+     */
+    readonly useCrossRegionInference?: boolean;
+    /**
+     * Prefix for cross-region inference configuration.
+     * Only used when useCrossRegionInference is true.
+     * @default BedrockCrossRegionInferencePrefix.US
+     */
+    readonly crossRegionInferencePrefix?: BedrockCrossRegionInferencePrefix;
+}
+/**
+ * Cross-region inference prefix options for Bedrock models.
+ * Used to configure inference profiles for improved availability and performance.
+ */
+export declare enum BedrockCrossRegionInferencePrefix {
+    /** US-based cross-region inference profile */
+    US = "us",
+    /** EU-based cross-region inference profile */
+    EU = "eu"
+}
+/**
+ * Document processing workflow powered by Amazon Bedrock foundation models.
+ *
+ * Extends BaseDocumentProcessing to provide AI-powered document classification and extraction
+ * using Amazon Bedrock foundation models. This implementation offers:
+ *
+ * ## Key Features
+ * - **AI-Powered Classification**: Uses Claude 3.7 Sonnet (configurable) to classify document types
+ * - **Intelligent Extraction**: Extracts structured data from documents using foundation models
+ * - **Cross-Region Inference**: Optional support for improved availability via inference profiles
+ * - **Flexible Processing**: Optional enrichment and post-processing Lambda functions
+ * - **Cost Optimized**: Configurable timeouts and model selection for cost control
+ *
+ * ## Processing Workflow
+ * S3 Upload → Classification (Bedrock) → Extraction (Bedrock) → [Enrichment] → [Post-Processing] → Results
+ *
+ * ## Default Models
+ * - Classification: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)
+ * - Extraction: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)
+ *
+ * ## Prompt Templates
+ * The construct uses default prompts that can be customized:
+ * - **Classification**: Analyzes document and returns JSON with documentClassification field
+ * - **Extraction**: Uses classification result to extract entities in structured JSON format
+ *
+ * ## Cross-Region Inference
+ * When enabled, uses Bedrock inference profiles for improved availability:
+ * - US prefix: Routes to US-based regions for lower latency
+ * - EU prefix: Routes to EU-based regions for data residency compliance
+ */
+export declare class BedrockDocumentProcessing extends BaseDocumentProcessing {
+    protected static readonly DEFAULT_CLASSIFICATION_MODEL_ID: FoundationModelIdentifier;
+    protected static readonly DEFAULT_PROCESSING_MODEL_ID: FoundationModelIdentifier;
+    protected static readonly DEFAULT_CLASSIFICATION_PROMPT = "\n  Analyze the document below, and classify the type of document it is (eg. INVOICE, IDENTITY_DOCUMENT, RECEIPT, etc). The result should be in JSON and should follow the following structure (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):\n\n  {\n      documentClassification: <CLASSIFICATION>\n  }\n\n  Attached document is as follows:\n\n  ";
+    protected static readonly DEFAULT_PROCESSING_PROMPT = "\n  The document below has been classified as [ACTUAL_CLASSIFICATION]. Extract important entities from the document and return the result as JSON following the structure below (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):\n\n  {\n      documentClassification: <CLASSIFICATION>,\n      result: {\n        entities: [\n            {\n                type: <TYPE OF ENTITY>\n                value: <VALUE OF ENTITY>\n            },\n            ...\n        ]\n      }\n  }\n\n  Attached document is as follows:\n\n  ";
+    /** Configuration properties specific to Bedrock document processing */
+    protected readonly bedrockDocumentProcessingProps: BedrockDocumentProcessingProps;
+    /** Cross-region inference prefix for Bedrock model routing */
+    protected readonly crossRegionInferencePrefix: BedrockCrossRegionInferencePrefix;
+    /** The Step Functions state machine that orchestrates the document processing workflow */
+    readonly stateMachine: StateMachine;
+    /**
+     * Creates a new BedrockDocumentProcessing construct.
+     *
+     * Initializes the Bedrock-powered document processing pipeline with AI classification
+     * and extraction capabilities. Creates Lambda functions with appropriate IAM roles
+     * for Bedrock model invocation and S3 access.
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The scoped construct ID. Must be unique within the scope.
+     * @param props - Configuration properties for the Bedrock document processing pipeline
+     */
+    constructor(scope: Construct, id: string, props: BedrockDocumentProcessingProps);
+    /**
+     * Implements the document classification step using Amazon Bedrock.
+     *
+     * Creates a Lambda function that invokes the configured Bedrock model to classify
+     * the document type. The function reads the document from S3 and sends it to
+     * Bedrock with the classification prompt.
+     *
+     * @returns LambdaInvoke task configured for document classification
+     */
+    protected classificationStep(): DocumentProcessingStepType;
+    /**
+     * Implements the document extraction step using Amazon Bedrock.
+     *
+     * Creates a Lambda function that invokes the configured Bedrock model to extract
+     * structured data from the document. Uses the classification result from the
+     * previous step to provide context for more accurate extraction.
+     *
+     * @returns LambdaInvoke task configured for document extraction
+     */
+    protected processingStep(): DocumentProcessingStepType;
+    protected generateLambdaRoleForBedrock(fmModel: FoundationModelIdentifier, id: string): Role;
+    /**
+     * Implements the optional document enrichment step.
+     *
+     * If an enrichment Lambda function is provided in the props, creates a LambdaInvoke
+     * task to perform additional processing on the extracted data. This step is useful
+     * for data validation, transformation, or integration with external systems.
+     *
+     * @returns LambdaInvoke task for enrichment, or undefined to skip this step
+     */
+    protected enrichmentStep(): DocumentProcessingStepType | undefined;
+    /**
+     * Implements the optional post-processing step.
+     *
+     * If a post-processing Lambda function is provided in the props, creates a LambdaInvoke
+     * task to perform final processing on the workflow results. This step is useful for
+     * data formatting, notifications, or integration with downstream systems.
+     *
+     * @returns LambdaInvoke task for post-processing, or undefined to skip this step
+     */
+    protected postProcessingStep(): DocumentProcessingStepType | undefined;
+}

package/lib/document-processing/bedrock-document-processing.js

@@ -0,0 +1,297 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockDocumentProcessing = exports.BedrockCrossRegionInferencePrefix = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const path = require("path");
+const aws_lambda_python_alpha_1 = require("@aws-cdk/aws-lambda-python-alpha");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_bedrock_1 = require("aws-cdk-lib/aws-bedrock");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_stepfunctions_tasks_1 = require("aws-cdk-lib/aws-stepfunctions-tasks");
+const base_document_processing_1 = require("./base-document-processing");
+const framework_1 = require("../framework");
+const utilities_1 = require("../utilities");
+const powertools_config_1 = require("../utilities/observability/powertools-config");
+/**
+ * Cross-region inference prefix options for Bedrock models.
+ * Used to configure inference profiles for improved availability and performance.
+ */
+var BedrockCrossRegionInferencePrefix;
+(function (BedrockCrossRegionInferencePrefix) {
+    /** US-based cross-region inference profile */
+    BedrockCrossRegionInferencePrefix["US"] = "us";
+    /** EU-based cross-region inference profile */
+    BedrockCrossRegionInferencePrefix["EU"] = "eu";
+})(BedrockCrossRegionInferencePrefix || (exports.BedrockCrossRegionInferencePrefix = BedrockCrossRegionInferencePrefix = {}));
+/**
+ * Document processing workflow powered by Amazon Bedrock foundation models.
+ *
+ * Extends BaseDocumentProcessing to provide AI-powered document classification and extraction
+ * using Amazon Bedrock foundation models. This implementation offers:
+ *
+ * ## Key Features
+ * - **AI-Powered Classification**: Uses Claude 3.7 Sonnet (configurable) to classify document types
+ * - **Intelligent Extraction**: Extracts structured data from documents using foundation models
+ * - **Cross-Region Inference**: Optional support for improved availability via inference profiles
+ * - **Flexible Processing**: Optional enrichment and post-processing Lambda functions
+ * - **Cost Optimized**: Configurable timeouts and model selection for cost control
+ *
+ * ## Processing Workflow
+ * S3 Upload → Classification (Bedrock) → Extraction (Bedrock) → [Enrichment] → [Post-Processing] → Results
+ *
+ * ## Default Models
+ * - Classification: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)
+ * - Extraction: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)
+ *
+ * ## Prompt Templates
+ * The construct uses default prompts that can be customized:
+ * - **Classification**: Analyzes document and returns JSON with documentClassification field
+ * - **Extraction**: Uses classification result to extract entities in structured JSON format
+ *
+ * ## Cross-Region Inference
+ * When enabled, uses Bedrock inference profiles for improved availability:
+ * - US prefix: Routes to US-based regions for lower latency
+ * - EU prefix: Routes to EU-based regions for data residency compliance
+ */
+class BedrockDocumentProcessing extends base_document_processing_1.BaseDocumentProcessing {
+    /**
+     * Creates a new BedrockDocumentProcessing construct.
+     *
+     * Initializes the Bedrock-powered document processing pipeline with AI classification
+     * and extraction capabilities. Creates Lambda functions with appropriate IAM roles
+     * for Bedrock model invocation and S3 access.
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The scoped construct ID. Must be unique within the scope.
+     * @param props - Configuration properties for the Bedrock document processing pipeline
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        if (props.network) {
+            props.network.createServiceEndpoint('vpce-bedrock', aws_ec2_1.InterfaceVpcEndpointAwsService.BEDROCK);
+            props.network.createServiceEndpoint('vpce-bedrock-runtime', aws_ec2_1.InterfaceVpcEndpointAwsService.BEDROCK_RUNTIME);
+        }
+        this.bedrockDocumentProcessingProps = props;
+        this.crossRegionInferencePrefix = props.crossRegionInferencePrefix || BedrockCrossRegionInferencePrefix.US;
+        this.stateMachine = this.handleStateMachineCreation('bedrock-document-processing-workflow');
+    }
+    /**
+     * Implements the document classification step using Amazon Bedrock.
+     *
+     * Creates a Lambda function that invokes the configured Bedrock model to classify
+     * the document type. The function reads the document from S3 and sends it to
+     * Bedrock with the classification prompt.
+     *
+     * @returns LambdaInvoke task configured for document classification
+     */
+    classificationStep() {
+        const prompt = this.bedrockDocumentProcessingProps.classificationPrompt || BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_PROMPT;
+        const fmModel = this.bedrockDocumentProcessingProps.classificationModelId || BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_MODEL_ID;
+        const adjustedModelId = this.bedrockDocumentProcessingProps.useCrossRegionInference ? `${this.crossRegionInferencePrefix}.${fmModel.modelId}` : fmModel.modelId;
+        const role = this.generateLambdaRoleForBedrock(fmModel, 'ClassificationLambdaRole');
+        const { region, account } = aws_cdk_lib_1.Stack.of(this);
+        const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
+            account,
+            functionName: 'bedrock-idp-classification',
+            region,
+            scope: this,
+        });
+        this.encryptionKey.grantEncryptDecrypt(role);
+        if (this.bucketEncryptionKey) {
+            this.bucketEncryptionKey.grantEncryptDecrypt(role);
+        }
+        const bedrockFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'BedrockClassificationFunction', {
+            functionName: generatedLogPermissions.uniqueFunctionName,
+            architecture: aws_lambda_1.Architecture.X86_64,
+            runtime: framework_1.DefaultRuntimes.PYTHON,
+            entry: path.join(__dirname, 'resources/default-bedrock-invoke'),
+            role,
+            memorySize: 512,
+            timeout: this.bedrockDocumentProcessingProps.stepTimeouts || aws_cdk_lib_1.Duration.minutes(5),
+            environment: {
+                MODEL_ID: adjustedModelId,
+                PROMPT: prompt,
+                INVOKE_TYPE: 'classification',
+                ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
+            },
+            environmentEncryption: this.encryptionKey,
+            vpc: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.vpc : undefined,
+            vpcSubnets: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection() : undefined,
+        });
+        for (const statement of generatedLogPermissions.policyStatements) {
+            bedrockFunction.role?.addToPrincipalPolicy(statement);
+        }
+        if (this.bedrockDocumentProcessingProps.network) {
+            bedrockFunction.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+        }
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'ClassificationStep', {
+            lambdaFunction: bedrockFunction,
+            resultPath: '$.classificationResult',
+            resultSelector: {
+                'documentClassification.$': '$.Payload.documentClassification',
+            },
+        });
+    }
+    /**
+     * Implements the document extraction step using Amazon Bedrock.
+     *
+     * Creates a Lambda function that invokes the configured Bedrock model to extract
+     * structured data from the document. Uses the classification result from the
+     * previous step to provide context for more accurate extraction.
+     *
+     * @returns LambdaInvoke task configured for document extraction
+     */
+    processingStep() {
+        const prompt = this.bedrockDocumentProcessingProps.processingPrompt || BedrockDocumentProcessing.DEFAULT_PROCESSING_PROMPT;
+        const fmModel = this.bedrockDocumentProcessingProps.processingModelId || BedrockDocumentProcessing.DEFAULT_PROCESSING_MODEL_ID;
+        const adjustedModelId = this.bedrockDocumentProcessingProps.useCrossRegionInference ? `${this.crossRegionInferencePrefix}.${fmModel.modelId}` : fmModel.modelId;
+        const role = this.generateLambdaRoleForBedrock(fmModel, 'ProcessingLambdaRole');
+        const { region, account } = aws_cdk_lib_1.Stack.of(this);
+        const generatedLogPermissions = utilities_1.LambdaIamUtils.createLogsPermissions({
+            account,
+            functionName: 'bedrock-idp-processing',
+            region,
+            scope: this,
+        });
+        this.encryptionKey.grantEncryptDecrypt(role);
+        if (this.bucketEncryptionKey) {
+            this.bucketEncryptionKey.grantEncryptDecrypt(role);
+        }
+        const bedrockFunction = new aws_lambda_python_alpha_1.PythonFunction(this, 'BedrockExtractionFunction', {
+            functionName: generatedLogPermissions.uniqueFunctionName,
+            runtime: framework_1.DefaultRuntimes.PYTHON,
+            architecture: aws_lambda_1.Architecture.X86_64,
+            entry: path.join(__dirname, 'resources/default-bedrock-invoke'),
+            role,
+            memorySize: 512,
+            timeout: this.bedrockDocumentProcessingProps.stepTimeouts || aws_cdk_lib_1.Duration.minutes(5),
+            environment: {
+                MODEL_ID: adjustedModelId,
+                PROMPT: prompt,
+                INVOKE_TYPE: 'processing',
+                ...powertools_config_1.PowertoolsConfig.generateDefaultLambdaConfig(this.bedrockDocumentProcessingProps.enableObservability, this.metricNamespace, this.metricServiceName),
+            },
+            environmentEncryption: this.encryptionKey,
+            vpc: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.vpc : undefined,
+            vpcSubnets: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection() : undefined,
+        });
+        for (const statement of generatedLogPermissions.policyStatements) {
+            bedrockFunction.role?.addToPrincipalPolicy(statement);
+        }
+        if (this.bedrockDocumentProcessingProps.network) {
+            bedrockFunction.role?.addToPrincipalPolicy(utilities_1.LambdaIamUtils.generateLambdaVPCPermissions());
+        }
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'ProcessingStep', {
+            lambdaFunction: bedrockFunction,
+            resultPath: '$.processingResult',
+            resultSelector: {
+                'documentClassification.$': '$.Payload.documentClassification',
+                'result.$': '$.Payload.result',
+            },
+        });
+    }
+    generateLambdaRoleForBedrock(fmModel, id) {
+        const { region, account } = aws_cdk_lib_1.Stack.of(this);
+        return new aws_iam_1.Role(this, id, {
+            assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+            inlinePolicies: {
+                BedrockInvokePolicy: new aws_iam_1.PolicyDocument({
+                    statements: [
+                        new aws_iam_1.PolicyStatement({
+                            effect: aws_iam_1.Effect.ALLOW,
+                            actions: ['s3:GetObject'],
+                            resources: [`${this.bucket.bucketArn}/*`],
+                        }),
+                        new aws_iam_1.PolicyStatement({
+                            effect: aws_iam_1.Effect.ALLOW,
+                            actions: [
+                                'bedrock:InvokeModel',
+                                'bedrock:InvokeModelWithResponseStream',
+                            ],
+                            resources: [
+                                `arn:aws:bedrock:*::foundation-model/${fmModel.modelId}`,
+                                `arn:aws:bedrock:${region}:${account}:inference-profile/${this.crossRegionInferencePrefix}.${fmModel.modelId}`,
+                            ],
+                        }),
+                    ],
+                }),
+            },
+        });
+    }
+    /**
+     * Implements the optional document enrichment step.
+     *
+     * If an enrichment Lambda function is provided in the props, creates a LambdaInvoke
+     * task to perform additional processing on the extracted data. This step is useful
+     * for data validation, transformation, or integration with external systems.
+     *
+     * @returns LambdaInvoke task for enrichment, or undefined to skip this step
+     */
+    enrichmentStep() {
+        if (!this.bedrockDocumentProcessingProps.enrichmentLambdaFunction) {
+            return undefined;
+        }
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'EnrichmentStep', {
+            lambdaFunction: this.bedrockDocumentProcessingProps.enrichmentLambdaFunction,
+            resultPath: '$.enrichedResult',
+        });
+    }
+    /**
+     * Implements the optional post-processing step.
+     *
+     * If a post-processing Lambda function is provided in the props, creates a LambdaInvoke
+     * task to perform final processing on the workflow results. This step is useful for
+     * data formatting, notifications, or integration with downstream systems.
+     *
+     * @returns LambdaInvoke task for post-processing, or undefined to skip this step
+     */
+    postProcessingStep() {
+        if (!this.bedrockDocumentProcessingProps.postProcessingLambdaFunction) {
+            return undefined;
+        }
+        return new aws_stepfunctions_tasks_1.LambdaInvoke(this, 'PostProcessingStep', {
+            lambdaFunction: this.bedrockDocumentProcessingProps.postProcessingLambdaFunction,
+            resultPath: '$.postProcessedResult',
+        });
+    }
+}
+exports.BedrockDocumentProcessing = BedrockDocumentProcessing;
+_a = JSII_RTTI_SYMBOL_1;
+BedrockDocumentProcessing[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.BedrockDocumentProcessing", version: "1.0.0" };
+BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_MODEL_ID = aws_bedrock_1.FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_7_SONNET_20250219_V1_0;
+BedrockDocumentProcessing.DEFAULT_PROCESSING_MODEL_ID = aws_bedrock_1.FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_7_SONNET_20250219_V1_0;
+BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_PROMPT = `
+  Analyze the document below, and classify the type of document it is (eg. INVOICE, IDENTITY_DOCUMENT, RECEIPT, etc). The result should be in JSON and should follow the following structure (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):
+
+  {
+      documentClassification: <CLASSIFICATION>
+  }
+
+  Attached document is as follows:
+
+  `;
+BedrockDocumentProcessing.DEFAULT_PROCESSING_PROMPT = `
+  The document below has been classified as [ACTUAL_CLASSIFICATION]. Extract important entities from the document and return the result as JSON following the structure below (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):
+
+  {
+      documentClassification: <CLASSIFICATION>,
+      result: {
+        entities: [
+            {
+                type: <TYPE OF ENTITY>
+                value: <VALUE OF ENTITY>
+            },
+            ...
+        ]
+      }
+  }
+
+  Attached document is as follows:
+
+  `;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bedrock-document-processing.js","sourceRoot":"","sources":["../../use-cases/document-processing/bedrock-document-processing.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as path from 'path';\nimport { PythonFunction } from '@aws-cdk/aws-lambda-python-alpha';\nimport { Duration, Stack } from 'aws-cdk-lib';\nimport { FoundationModelIdentifier } from 'aws-cdk-lib/aws-bedrock';\nimport { InterfaceVpcEndpointAwsService } from 'aws-cdk-lib/aws-ec2';\nimport { Role, ServicePrincipal, PolicyStatement, PolicyDocument, Effect } from 'aws-cdk-lib/aws-iam';\nimport { Function, Architecture } from 'aws-cdk-lib/aws-lambda';\nimport { StateMachine } from 'aws-cdk-lib/aws-stepfunctions';\nimport { LambdaInvoke } from 'aws-cdk-lib/aws-stepfunctions-tasks';\nimport { Construct } from 'constructs';\nimport { BaseDocumentProcessing, BaseDocumentProcessingProps, DocumentProcessingStepType } from './base-document-processing';\nimport { DefaultRuntimes } from '../framework';\nimport { LambdaIamUtils } from '../utilities';\nimport { PowertoolsConfig } from '../utilities/observability/powertools-config';\n\n/**\n * Configuration properties for BedrockDocumentProcessing construct.\n * Extends BaseDocumentProcessingProps with Bedrock-specific options.\n */\nexport interface BedrockDocumentProcessingProps extends BaseDocumentProcessingProps {\n  /**\n   * Bedrock foundation model for document classification step.\n   * @default FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_7_SONNET_20250219_V1_0\n   */\n  readonly classificationModelId?: FoundationModelIdentifier;\n  /**\n   * Bedrock foundation model for document extraction step.\n   * @default FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_7_SONNET_20250219_V1_0\n   */\n  readonly processingModelId?: FoundationModelIdentifier;\n  /**\n   * Custom prompt template for document classification.\n   * Must include placeholder for document content.\n   * @default DEFAULT_CLASSIFICATION_PROMPT\n   */\n  readonly classificationPrompt?: string;\n  /**\n   * Custom prompt template for document extraction.\n   * Must include placeholder for document content and classification result.\n   * @default DEFAULT_EXTRACTION_PROMPT\n   */\n  readonly processingPrompt?: string;\n  /**\n   * Optional Lambda function for document enrichment step.\n   * If provided, will be invoked after extraction with workflow state.\n   */\n  readonly enrichmentLambdaFunction?: Function;\n  /**\n   * Optional Lambda function for post-processing step.\n   * If provided, will be invoked after enrichment with workflow state.\n   */\n  readonly postProcessingLambdaFunction?: Function;\n  /**\n   * Timeout for individual Step Functions tasks (classification, extraction, etc.).\n   * @default Duration.minutes(5)\n   */\n  readonly stepTimeouts?: Duration;\n  /**\n   * Enable cross-region inference for Bedrock models to improve availability and performance.\n   * When enabled, uses inference profiles instead of direct model invocation.\n   * @default false\n   */\n  readonly useCrossRegionInference?: boolean;\n  /**\n   * Prefix for cross-region inference configuration.\n   * Only used when useCrossRegionInference is true.\n   * @default BedrockCrossRegionInferencePrefix.US\n   */\n  readonly crossRegionInferencePrefix?: BedrockCrossRegionInferencePrefix;\n}\n\n/**\n * Cross-region inference prefix options for Bedrock models.\n * Used to configure inference profiles for improved availability and performance.\n */\nexport enum BedrockCrossRegionInferencePrefix {\n  /** US-based cross-region inference profile */\n  US = 'us',\n  /** EU-based cross-region inference profile */\n  EU = 'eu',\n}\n\n/**\n * Document processing workflow powered by Amazon Bedrock foundation models.\n *\n * Extends BaseDocumentProcessing to provide AI-powered document classification and extraction\n * using Amazon Bedrock foundation models. This implementation offers:\n *\n * ## Key Features\n * - **AI-Powered Classification**: Uses Claude 3.7 Sonnet (configurable) to classify document types\n * - **Intelligent Extraction**: Extracts structured data from documents using foundation models\n * - **Cross-Region Inference**: Optional support for improved availability via inference profiles\n * - **Flexible Processing**: Optional enrichment and post-processing Lambda functions\n * - **Cost Optimized**: Configurable timeouts and model selection for cost control\n *\n * ## Processing Workflow\n * S3 Upload → Classification (Bedrock) → Extraction (Bedrock) → [Enrichment] → [Post-Processing] → Results\n *\n * ## Default Models\n * - Classification: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)\n * - Extraction: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)\n *\n * ## Prompt Templates\n * The construct uses default prompts that can be customized:\n * - **Classification**: Analyzes document and returns JSON with documentClassification field\n * - **Extraction**: Uses classification result to extract entities in structured JSON format\n *\n * ## Cross-Region Inference\n * When enabled, uses Bedrock inference profiles for improved availability:\n * - US prefix: Routes to US-based regions for lower latency\n * - EU prefix: Routes to EU-based regions for data residency compliance\n */\nexport class BedrockDocumentProcessing extends BaseDocumentProcessing {\n\n  protected static readonly DEFAULT_CLASSIFICATION_MODEL_ID: FoundationModelIdentifier\n    = FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_7_SONNET_20250219_V1_0;\n  protected static readonly DEFAULT_PROCESSING_MODEL_ID: FoundationModelIdentifier\n    = FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_7_SONNET_20250219_V1_0;\n  protected static readonly DEFAULT_CLASSIFICATION_PROMPT = `\n  Analyze the document below, and classify the type of document it is (eg. INVOICE, IDENTITY_DOCUMENT, RECEIPT, etc). The result should be in JSON and should follow the following structure (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):\n\n  {\n      documentClassification: <CLASSIFICATION>\n  }\n\n  Attached document is as follows:\n\n  `;\n\n  protected static readonly DEFAULT_PROCESSING_PROMPT = `\n  The document below has been classified as [ACTUAL_CLASSIFICATION]. Extract important entities from the document and return the result as JSON following the structure below (only respond in JSON with the following structure and do not use markdown to indicate the json, just output plain old json with nothing else):\n\n  {\n      documentClassification: <CLASSIFICATION>,\n      result: {\n        entities: [\n            {\n                type: <TYPE OF ENTITY>\n                value: <VALUE OF ENTITY>\n            },\n            ...\n        ]\n      }\n  }\n\n  Attached document is as follows:\n\n  `;\n\n  /** Configuration properties specific to Bedrock document processing */\n  protected readonly bedrockDocumentProcessingProps: BedrockDocumentProcessingProps;\n  /** Cross-region inference prefix for Bedrock model routing */\n  protected readonly crossRegionInferencePrefix: BedrockCrossRegionInferencePrefix;\n  /** The Step Functions state machine that orchestrates the document processing workflow */\n  readonly stateMachine: StateMachine;\n\n  /**\n   * Creates a new BedrockDocumentProcessing construct.\n   *\n   * Initializes the Bedrock-powered document processing pipeline with AI classification\n   * and extraction capabilities. Creates Lambda functions with appropriate IAM roles\n   * for Bedrock model invocation and S3 access.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The scoped construct ID. Must be unique within the scope.\n   * @param props - Configuration properties for the Bedrock document processing pipeline\n   */\n  constructor(scope: Construct, id: string, props: BedrockDocumentProcessingProps) {\n    super(scope, id, props);\n    if (props.network) {\n      props.network.createServiceEndpoint('vpce-bedrock', InterfaceVpcEndpointAwsService.BEDROCK);\n      props.network.createServiceEndpoint('vpce-bedrock-runtime', InterfaceVpcEndpointAwsService.BEDROCK_RUNTIME);\n    }\n\n    this.bedrockDocumentProcessingProps = props;\n    this.crossRegionInferencePrefix = props.crossRegionInferencePrefix || BedrockCrossRegionInferencePrefix.US;\n    this.stateMachine = this.handleStateMachineCreation('bedrock-document-processing-workflow');\n  }\n\n  /**\n   * Implements the document classification step using Amazon Bedrock.\n   *\n   * Creates a Lambda function that invokes the configured Bedrock model to classify\n   * the document type. The function reads the document from S3 and sends it to\n   * Bedrock with the classification prompt.\n   *\n   * @returns LambdaInvoke task configured for document classification\n   */\n  protected classificationStep(): DocumentProcessingStepType {\n    const prompt = this.bedrockDocumentProcessingProps.classificationPrompt || BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_PROMPT;\n    const fmModel = this.bedrockDocumentProcessingProps.classificationModelId || BedrockDocumentProcessing.DEFAULT_CLASSIFICATION_MODEL_ID;\n    const adjustedModelId = this.bedrockDocumentProcessingProps.useCrossRegionInference ? `${this.crossRegionInferencePrefix}.${fmModel.modelId}` : fmModel.modelId;\n    const role = this.generateLambdaRoleForBedrock(fmModel, 'ClassificationLambdaRole');\n    const { region, account } = Stack.of(this);\n    const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n      account,\n      functionName: 'bedrock-idp-classification',\n      region,\n      scope: this,\n    });\n\n    this.encryptionKey.grantEncryptDecrypt(role);\n\n    if (this.bucketEncryptionKey) {\n      this.bucketEncryptionKey.grantEncryptDecrypt(role);\n    }\n\n    const bedrockFunction = new PythonFunction(this, 'BedrockClassificationFunction', {\n      functionName: generatedLogPermissions.uniqueFunctionName,\n      architecture: Architecture.X86_64,\n      runtime: DefaultRuntimes.PYTHON,\n      entry: path.join(__dirname, 'resources/default-bedrock-invoke'),\n      role,\n      memorySize: 512,\n      timeout: this.bedrockDocumentProcessingProps.stepTimeouts || Duration.minutes(5),\n      environment: {\n        MODEL_ID: adjustedModelId,\n        PROMPT: prompt,\n        INVOKE_TYPE: 'classification',\n        ...PowertoolsConfig.generateDefaultLambdaConfig(\n          this.bedrockDocumentProcessingProps.enableObservability,\n          this.metricNamespace,\n          this.metricServiceName,\n        ),\n      },\n      environmentEncryption: this.encryptionKey,\n      vpc: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.vpc : undefined,\n      vpcSubnets: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection() : undefined,\n    });\n\n    for (const statement of generatedLogPermissions.policyStatements) {\n      bedrockFunction.role?.addToPrincipalPolicy(statement);\n    }\n\n    if (this.bedrockDocumentProcessingProps.network) {\n      bedrockFunction.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n    }\n\n    return new LambdaInvoke(this, 'ClassificationStep', {\n      lambdaFunction: bedrockFunction,\n      resultPath: '$.classificationResult',\n      resultSelector: {\n        'documentClassification.$': '$.Payload.documentClassification',\n      },\n    });\n  }\n\n  /**\n   * Implements the document extraction step using Amazon Bedrock.\n   *\n   * Creates a Lambda function that invokes the configured Bedrock model to extract\n   * structured data from the document. Uses the classification result from the\n   * previous step to provide context for more accurate extraction.\n   *\n   * @returns LambdaInvoke task configured for document extraction\n   */\n  protected processingStep(): DocumentProcessingStepType {\n    const prompt = this.bedrockDocumentProcessingProps.processingPrompt || BedrockDocumentProcessing.DEFAULT_PROCESSING_PROMPT;\n    const fmModel = this.bedrockDocumentProcessingProps.processingModelId || BedrockDocumentProcessing.DEFAULT_PROCESSING_MODEL_ID;\n    const adjustedModelId = this.bedrockDocumentProcessingProps.useCrossRegionInference ? `${this.crossRegionInferencePrefix}.${fmModel.modelId}` : fmModel.modelId;\n    const role = this.generateLambdaRoleForBedrock(fmModel, 'ProcessingLambdaRole');\n    const { region, account } = Stack.of(this);\n\n    const generatedLogPermissions = LambdaIamUtils.createLogsPermissions({\n      account,\n      functionName: 'bedrock-idp-processing',\n      region,\n      scope: this,\n    });\n    this.encryptionKey.grantEncryptDecrypt(role);\n    if (this.bucketEncryptionKey) {\n      this.bucketEncryptionKey.grantEncryptDecrypt(role);\n    }\n    const bedrockFunction = new PythonFunction(this, 'BedrockExtractionFunction', {\n      functionName: generatedLogPermissions.uniqueFunctionName,\n      runtime: DefaultRuntimes.PYTHON,\n      architecture: Architecture.X86_64,\n      entry: path.join(__dirname, 'resources/default-bedrock-invoke'),\n      role,\n      memorySize: 512,\n      timeout: this.bedrockDocumentProcessingProps.stepTimeouts || Duration.minutes(5),\n      environment: {\n        MODEL_ID: adjustedModelId,\n        PROMPT: prompt,\n        INVOKE_TYPE: 'processing',\n        ...PowertoolsConfig.generateDefaultLambdaConfig(\n          this.bedrockDocumentProcessingProps.enableObservability,\n          this.metricNamespace,\n          this.metricServiceName,\n        ),\n      },\n      environmentEncryption: this.encryptionKey,\n      vpc: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.vpc : undefined,\n      vpcSubnets: this.bedrockDocumentProcessingProps.network ? this.bedrockDocumentProcessingProps.network.applicationSubnetSelection() : undefined,\n    });\n\n    for (const statement of generatedLogPermissions.policyStatements) {\n      bedrockFunction.role?.addToPrincipalPolicy(statement);\n    }\n\n    if (this.bedrockDocumentProcessingProps.network) {\n      bedrockFunction.role?.addToPrincipalPolicy(LambdaIamUtils.generateLambdaVPCPermissions());\n    }\n\n    return new LambdaInvoke(this, 'ProcessingStep', {\n      lambdaFunction: bedrockFunction,\n      resultPath: '$.processingResult',\n      resultSelector: {\n        'documentClassification.$': '$.Payload.documentClassification',\n        'result.$': '$.Payload.result',\n      },\n    });\n  }\n\n  protected generateLambdaRoleForBedrock(fmModel: FoundationModelIdentifier, id: string) {\n    const { region, account } = Stack.of(this);\n    return new Role(this, id, {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      inlinePolicies: {\n        BedrockInvokePolicy: new PolicyDocument({\n          statements: [\n            new PolicyStatement({\n              effect: Effect.ALLOW,\n              actions: ['s3:GetObject'],\n              resources: [`${this.bucket.bucketArn}/*`],\n            }),\n            new PolicyStatement({\n              effect: Effect.ALLOW,\n              actions: [\n                'bedrock:InvokeModel',\n                'bedrock:InvokeModelWithResponseStream',\n              ],\n              resources: [\n                `arn:aws:bedrock:*::foundation-model/${fmModel.modelId}`,\n                `arn:aws:bedrock:${region}:${account}:inference-profile/${this.crossRegionInferencePrefix}.${fmModel.modelId}`,\n              ],\n            }),\n          ],\n        }),\n      },\n    });\n  }\n\n  /**\n   * Implements the optional document enrichment step.\n   *\n   * If an enrichment Lambda function is provided in the props, creates a LambdaInvoke\n   * task to perform additional processing on the extracted data. This step is useful\n   * for data validation, transformation, or integration with external systems.\n   *\n   * @returns LambdaInvoke task for enrichment, or undefined to skip this step\n   */\n  protected enrichmentStep(): DocumentProcessingStepType | undefined {\n    if (!this.bedrockDocumentProcessingProps.enrichmentLambdaFunction) {\n      return undefined;\n    }\n\n    return new LambdaInvoke(this, 'EnrichmentStep', {\n      lambdaFunction: this.bedrockDocumentProcessingProps.enrichmentLambdaFunction,\n      resultPath: '$.enrichedResult',\n    });\n  }\n\n  /**\n   * Implements the optional post-processing step.\n   *\n   * If a post-processing Lambda function is provided in the props, creates a LambdaInvoke\n   * task to perform final processing on the workflow results. This step is useful for\n   * data formatting, notifications, or integration with downstream systems.\n   *\n   * @returns LambdaInvoke task for post-processing, or undefined to skip this step\n   */\n  protected postProcessingStep(): DocumentProcessingStepType | undefined {\n    if (!this.bedrockDocumentProcessingProps.postProcessingLambdaFunction) {\n      return undefined;\n    }\n\n    return new LambdaInvoke(this, 'PostProcessingStep', {\n      lambdaFunction: this.bedrockDocumentProcessingProps.postProcessingLambdaFunction,\n      resultPath: '$.postProcessedResult',\n    });\n  }\n}"]}

package/lib/document-processing/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base-document-processing';
+export * from './bedrock-document-processing';
+export * from './agentic-document-processing';

package/lib/document-processing/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base-document-processing"), exports);
+__exportStar(require("./bedrock-document-processing"), exports);
+__exportStar(require("./agentic-document-processing"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi91c2UtY2FzZXMvZG9jdW1lbnQtcHJvY2Vzc2luZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNkRBQTJDO0FBQzNDLGdFQUE4QztBQUM5QyxnRUFBOEMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Jhc2UtZG9jdW1lbnQtcHJvY2Vzc2luZyc7XG5leHBvcnQgKiBmcm9tICcuL2JlZHJvY2stZG9jdW1lbnQtcHJvY2Vzc2luZyc7XG5leHBvcnQgKiBmcm9tICcuL2FnZW50aWMtZG9jdW1lbnQtcHJvY2Vzc2luZyc7Il19

package/lib/document-processing/resources/default-bedrock-invoke/index.py

@@ -0,0 +1,63 @@
+import json
+import os
+import boto3
+import base64
+from aws_lambda_powertools import Metrics, Tracer
+from aws_lambda_powertools.metrics import MetricUnit
+
+s3 = boto3.client('s3')
+bedrock = boto3.client('bedrock-runtime')
+metrics = Metrics()
+tracer = Tracer()
+
+@metrics.log_metrics
+@tracer.capture_lambda_handler
+def handler(event, context):
+    bucket = event['bucket']
+    key = event['key']
+    invoke_type = os.environ["INVOKE_TYPE"]
+    tracer.put_annotation(key="invoke_type", value=invoke_type)
+    tracer.put_annotation(key="documentId", value=event["documentId"])
+    metrics.add_dimension(name="invoke_type", value=invoke_type)
+    
+    # Check file type
+    ext = key.lower().split('.')[-1]
+    if ext not in ['jpg', 'jpeg', 'png', 'pdf']:
+        raise ValueError(f"Unsupported file type: {ext}")
+    
+    media_type = {'jpg': 'image/jpeg', 'jpeg': 'image/jpeg', 'png': 'image/png', 'pdf': 'application/pdf'}[ext]
+    
+    # Download file to /tmp
+    local_path = f"/tmp/{key.split('/')[-1]}"
+    s3.download_file(bucket, key, local_path)
+    
+    # Read and encode file
+    with open(local_path, 'rb') as f:
+        file_data = base64.b64encode(f.read()).decode('utf-8')
+    
+    # Format prompt if classification result exists
+    prompt = os.environ['PROMPT']
+    if 'classificationResult' in event:
+        classification = event['classificationResult']['documentClassification']
+        prompt = prompt.replace("[ACTUAL_CLASSIFICATION]", classification)
+    
+    # Build content based on file type
+    content = [{'type': 'text', 'text': prompt}]
+    if ext == 'pdf':
+        content.append({'type': 'document', 'source': {'type': 'base64', 'media_type': media_type, 'data': file_data}})
+    else:
+        content.append({'type': 'image', 'source': {'type': 'base64', 'media_type': media_type, 'data': file_data}})
+    
+    # Invoke Bedrock
+    response = bedrock.invoke_model(
+        modelId=os.environ['MODEL_ID'],
+        body=json.dumps({
+            'anthropic_version': 'bedrock-2023-05-31',
+            'max_tokens': 1000,
+            'messages': [{'role': 'user', 'content': content}]
+        })
+    )
+    
+    response_payload = response['body'].read()
+    metrics.add_metric(name="SuccessfulInvocation", unit=MetricUnit.Count, value=1)
+    return json.loads(json.loads(response_payload)["content"][0]["text"])

package/lib/document-processing/resources/default-bedrock-invoke/requirements.txt

@@ -0,0 +1,4 @@
+boto3>=1.26.0
+aws-lambda-powertools
+urllib3>=1.26.0,<2.0.0
+aws-xray-sdk