@cdklabs/cdk-appmod-catalog-blueprints 1.5.0 → 1.6.0

package/lib/document-processing/chunking-config.d.ts

@@ -0,0 +1,614 @@
+/**
+ * Chunking strategy options for PDF document processing.
+ *
+ * Choose the strategy based on your document characteristics:
+ *
+ * - **fixed-pages**: Legacy approach, splits by fixed page count.
+ *   - Pros: Fast, simple, predictable chunk sizes
+ *   - Cons: May exceed token limits for dense documents
+ *   - Best for: Uniform density documents, simple text
+ *
+ * - **token-based**: Splits based on token count to respect model limits.
+ *   - Pros: Respects model token limits, handles variable density
+ *   - Cons: Slower analysis, variable chunk sizes
+ *   - Best for: Variable density documents, technical content
+ *
+ * - **hybrid**: RECOMMENDED - Balances token count and page limits.
+ *   - Pros: Best of both worlds, reliable, flexible
+ *   - Cons: Slightly more complex configuration
+ *   - Best for: Most documents, general-purpose processing
+ */
+export type ChunkingStrategy = 'fixed-pages' | 'token-based' | 'hybrid';
+/**
+ * Processing mode for chunked documents.
+ *
+ * - **sequential**: Process chunks one at a time (cost-optimized)
+ * - **parallel**: Process multiple chunks simultaneously (speed-optimized)
+ */
+export type ProcessingMode = 'sequential' | 'parallel';
+/**
+ * Aggregation strategy for combining chunk results.
+ *
+ * - **majority-vote**: Select most frequent classification across chunks
+ * - **weighted-vote**: Weight early chunks higher than later chunks
+ * - **first-chunk**: Use classification from first chunk only
+ */
+export type AggregationStrategy = 'majority-vote' | 'weighted-vote' | 'first-chunk';
+/**
+ * Configuration for fixed-pages chunking strategy.
+ * Splits documents by fixed page count (legacy approach).
+ */
+export interface FixedPagesConfig {
+    /**
+     * Threshold for triggering chunking based on page count.
+     * Documents with pages > threshold will be chunked.
+     * @default 100
+     */
+    readonly pageThreshold?: number;
+    /**
+     * Number of pages per chunk.
+     * @default 50
+     */
+    readonly chunkSize?: number;
+    /**
+     * Number of overlapping pages between consecutive chunks.
+     * Must be less than chunkSize.
+     * @default 5
+     */
+    readonly overlapPages?: number;
+}
+/**
+ * Configuration for token-based chunking strategy.
+ * Splits documents based on estimated token count to respect model limits.
+ */
+export interface TokenBasedConfig {
+    /**
+     * Threshold for triggering chunking based on token count.
+     * Documents with tokens > threshold will be chunked.
+     * @default 150000
+     */
+    readonly tokenThreshold?: number;
+    /**
+     * Maximum tokens per chunk.
+     * Ensures no chunk exceeds model token limits.
+     * @default 100000
+     */
+    readonly maxTokensPerChunk?: number;
+    /**
+     * Number of overlapping tokens between consecutive chunks.
+     * Provides context continuity across chunks.
+     * @default 5000
+     */
+    readonly overlapTokens?: number;
+}
+/**
+ * Configuration for hybrid chunking strategy (RECOMMENDED).
+ * Balances token count and page limits for optimal chunking.
+ */
+export interface HybridConfig {
+    /**
+     * Hard limit on pages per chunk.
+     * Prevents very large chunks even if token count is low.
+     * Note: Bedrock has a hard limit of 100 pages per PDF, so we default to 99
+     * to provide a safety margin.
+     * @default 99
+     */
+    readonly maxPagesPerChunk?: number;
+    /**
+     * Soft target for tokens per chunk.
+     * Chunks aim for this token count but respect maxPagesPerChunk.
+     * @default 80000
+     */
+    readonly targetTokensPerChunk?: number;
+    /**
+     * Threshold for triggering chunking based on page count.
+     * Documents with pages > threshold will be chunked.
+     * @default 100
+     */
+    readonly pageThreshold?: number;
+    /**
+     * Threshold for triggering chunking based on token count.
+     * Documents with tokens > threshold will be chunked.
+     * @default 150000
+     */
+    readonly tokenThreshold?: number;
+    /**
+     * Number of overlapping tokens between consecutive chunks.
+     * Provides context continuity across chunks.
+     * @default 5000
+     */
+    readonly overlapTokens?: number;
+}
+/**
+ * Comprehensive configuration for PDF chunking behavior.
+ *
+ * This interface provides fine-grained control over how large PDF documents are
+ * split into manageable chunks for processing. The chunking system supports three
+ * strategies, each optimized for different document types and use cases.
+ *
+ * ## Chunking Strategies
+ *
+ * ### 1. Hybrid Strategy (RECOMMENDED)
+ * Balances both token count and page limits for optimal chunking. Best for most
+ * documents as it respects model token limits while preventing excessively large chunks.
+ *
+ * ### 2. Token-Based Strategy
+ * Splits documents based on estimated token count. Best for documents with variable
+ * content density (e.g., mixed text and images, tables, charts).
+ *
+ * ### 3. Fixed-Pages Strategy (Legacy)
+ * Simple page-based splitting. Fast but may exceed token limits for dense documents.
+ * Use only for documents with uniform content density.
+ *
+ * ## Processing Modes
+ *
+ * - **parallel**: Process multiple chunks simultaneously (faster, higher cost)
+ * - **sequential**: Process chunks one at a time (slower, lower cost)
+ *
+ * ## Aggregation Strategies
+ *
+ * - **majority-vote**: Most frequent classification wins (recommended)
+ * - **weighted-vote**: Early chunks weighted higher
+ * - **first-chunk**: Use first chunk's classification only
+ *
+ * ## Default Values
+ *
+ * | Parameter | Default | Description |
+ * |-----------|---------|-------------|
+ * | strategy | 'hybrid' | Chunking strategy |
+ * | pageThreshold | 100 | Pages to trigger chunking |
+ * | tokenThreshold | 150000 | Tokens to trigger chunking |
+ * | chunkSize | 50 | Pages per chunk (fixed-pages) |
+ * | overlapPages | 5 | Overlap pages (fixed-pages) |
+ * | maxTokensPerChunk | 100000 | Max tokens per chunk (token-based) |
+ * | overlapTokens | 5000 | Overlap tokens (token-based, hybrid) |
+ * | targetTokensPerChunk | 80000 | Target tokens per chunk (hybrid) |
+ * | maxPagesPerChunk | 99 | Max pages per chunk (hybrid) |
+ * | processingMode | 'parallel' | Processing mode |
+ * | maxConcurrency | 10 | Max parallel chunks |
+ * | aggregationStrategy | 'majority-vote' | Result aggregation |
+ * | minSuccessThreshold | 0.5 | Min success rate for valid result |
+ */
+export interface ChunkingConfig {
+    /**
+     * Chunking strategy to use.
+     *
+     * - **hybrid** (RECOMMENDED): Balances token count and page limits
+     * - **token-based**: Respects model token limits, good for variable density
+     * - **fixed-pages**: Simple page-based splitting (legacy, not recommended)
+     *
+     * @default 'hybrid'
+     */
+    readonly strategy?: ChunkingStrategy;
+    /**
+     * Threshold for triggering chunking based on page count (fixed-pages strategy).
+     * @default 100
+     */
+    readonly pageThreshold?: number;
+    /**
+     * Number of pages per chunk (fixed-pages strategy).
+     * @default 50
+     */
+    readonly chunkSize?: number;
+    /**
+     * Number of overlapping pages between chunks (fixed-pages strategy).
+     * @default 5
+     */
+    readonly overlapPages?: number;
+    /**
+     * Threshold for triggering chunking based on token count (token-based strategy).
+     * @default 150000
+     */
+    readonly tokenThreshold?: number;
+    /**
+     * Maximum tokens per chunk (token-based strategy).
+     * @default 100000
+     */
+    readonly maxTokensPerChunk?: number;
+    /**
+     * Number of overlapping tokens between chunks (token-based and hybrid strategies).
+     * @default 5000
+     */
+    readonly overlapTokens?: number;
+    /**
+     * Hard limit on pages per chunk (hybrid strategy).
+     * Note: Bedrock has a hard limit of 100 pages per PDF, so we default to 99
+     * to provide a safety margin.
+     * @default 99
+     */
+    readonly maxPagesPerChunk?: number;
+    /**
+     * Soft target for tokens per chunk (hybrid strategy).
+     * @default 80000
+     */
+    readonly targetTokensPerChunk?: number;
+    /**
+     * Processing mode for chunks.
+     *
+     * - **parallel**: Process multiple chunks simultaneously (faster, higher cost)
+     * - **sequential**: Process chunks one at a time (slower, lower cost)
+     *
+     * @default 'parallel'
+     */
+    readonly processingMode?: ProcessingMode;
+    /**
+     * Maximum number of chunks to process concurrently (parallel mode only).
+     * Higher values increase speed but also cost.
+     *
+     * @default 10
+     */
+    readonly maxConcurrency?: number;
+    /**
+     * Strategy for aggregating results from multiple chunks.
+     *
+     * - **majority-vote**: Most frequent classification wins
+     * - **weighted-vote**: Early chunks weighted higher
+     * - **first-chunk**: Use first chunk's classification
+     *
+     * @default 'majority-vote'
+     */
+    readonly aggregationStrategy?: AggregationStrategy;
+    /**
+     * Minimum percentage of chunks that must succeed for aggregation.
+     * If fewer chunks succeed, the result is marked as partial failure.
+     *
+     * @default 0.5 (50%)
+     */
+    readonly minSuccessThreshold?: number;
+}
+/**
+ * Metadata about a single chunk of a document.
+ * Contains information about the chunk's position, size, and S3 location.
+ */
+export interface ChunkMetadata {
+    /**
+     * Unique identifier for this chunk.
+     * Format: {documentId}_chunk_{index}
+     */
+    readonly chunkId: string;
+    /**
+     * Zero-based index of this chunk in the document.
+     */
+    readonly chunkIndex: number;
+    /**
+     * Total number of chunks in the document.
+     */
+    readonly totalChunks: number;
+    /**
+     * Starting page number (zero-based) of this chunk.
+     */
+    readonly startPage: number;
+    /**
+     * Ending page number (zero-based, inclusive) of this chunk.
+     */
+    readonly endPage: number;
+    /**
+     * Number of pages in this chunk.
+     */
+    readonly pageCount: number;
+    /**
+     * Estimated token count for this chunk.
+     * Based on word-count heuristic (1.3 tokens per word).
+     */
+    readonly estimatedTokens: number;
+    /**
+     * S3 bucket containing the chunk file.
+     */
+    readonly bucket: string;
+    /**
+     * S3 key for the chunk file.
+     * Typically in chunks/ prefix.
+     */
+    readonly key: string;
+}
+/**
+ * Document content location information.
+ */
+export interface DocumentContent {
+    /**
+     * Storage location type (e.g., 's3').
+     */
+    readonly location: string;
+    /**
+     * S3 bucket containing the document.
+     */
+    readonly bucket: string;
+    /**
+     * S3 key for the document.
+     */
+    readonly key: string;
+    /**
+     * Original filename of the document.
+     */
+    readonly filename: string;
+}
+/**
+ * Request payload for PDF analysis and chunking Lambda.
+ * Contains document information and chunking configuration.
+ */
+export interface ChunkingRequest {
+    /**
+     * Unique identifier for the document.
+     */
+    readonly documentId: string;
+    /**
+     * Content type of the document.
+     * Typically 'file' for S3-based documents.
+     */
+    readonly contentType: string;
+    /**
+     * Document content location information.
+     */
+    readonly content: DocumentContent;
+    /**
+     * Optional chunking configuration.
+     * If not provided, uses default configuration.
+     */
+    readonly config?: ChunkingConfig;
+}
+/**
+ * Token analysis results from PDF analysis.
+ * Provides information about document size and token distribution.
+ */
+export interface TokenAnalysis {
+    /**
+     * Total estimated tokens in the document.
+     */
+    readonly totalTokens: number;
+    /**
+     * Total number of pages in the document.
+     */
+    readonly totalPages: number;
+    /**
+     * Average tokens per page across the document.
+     */
+    readonly avgTokensPerPage: number;
+    /**
+     * Optional detailed token count for each page.
+     * Used for token-based and hybrid chunking strategies.
+     */
+    readonly tokensPerPage?: number[];
+}
+/**
+ * Response when chunking is NOT required.
+ * Document is below thresholds and will be processed without chunking.
+ */
+export interface NoChunkingResponse {
+    /**
+     * Document identifier.
+     */
+    readonly documentId: string;
+    /**
+     * Indicates chunking is not required.
+     */
+    readonly requiresChunking: false;
+    /**
+     * Token analysis results.
+     */
+    readonly tokenAnalysis: TokenAnalysis;
+    /**
+     * Human-readable reason why chunking was not applied.
+     * Example: "Document has 50 pages, below threshold of 100"
+     */
+    readonly reason: string;
+}
+/**
+ * Chunking configuration used for processing.
+ * Includes both user-provided and default values.
+ */
+export interface ChunkingConfigUsed {
+    readonly strategy: ChunkingStrategy;
+    readonly totalPages: number;
+    readonly totalTokens: number;
+    readonly chunkSize?: number;
+    readonly overlapPages?: number;
+    readonly maxTokensPerChunk?: number;
+    readonly overlapTokens?: number;
+    readonly targetTokensPerChunk?: number;
+    readonly maxPagesPerChunk?: number;
+    readonly processingMode?: string;
+}
+/**
+ * Response when chunking IS required.
+ * Document exceeds thresholds and has been split into chunks.
+ */
+export interface ChunkingResponse {
+    /**
+     * Document identifier.
+     */
+    readonly documentId: string;
+    /**
+     * Indicates chunking is required.
+     */
+    readonly requiresChunking: true;
+    /**
+     * Token analysis results with detailed per-page information.
+     */
+    readonly tokenAnalysis: TokenAnalysis;
+    /**
+     * Strategy used for chunking.
+     */
+    readonly strategy: ChunkingStrategy;
+    /**
+     * Array of chunk metadata for all created chunks.
+     */
+    readonly chunks: ChunkMetadata[];
+    /**
+     * Configuration used for chunking.
+     * Includes both user-provided and default values.
+     */
+    readonly config: ChunkingConfigUsed;
+}
+/**
+ * Union type for chunking Lambda response.
+ * Either chunking is required or not.
+ */
+export type ChunkingLambdaResponse = NoChunkingResponse | ChunkingResponse;
+/**
+ * Classification result for a chunk.
+ */
+export interface ChunkClassificationResult {
+    readonly documentClassification: string;
+    readonly confidence?: number;
+}
+/**
+ * Processing result for a chunk.
+ */
+export interface ChunkProcessingResult {
+    readonly entities: Entity[];
+}
+/**
+ * Result from processing a single chunk.
+ * Contains classification and extraction results, or error information.
+ */
+export interface ChunkResult {
+    /**
+     * Chunk identifier.
+     */
+    readonly chunkId: string;
+    /**
+     * Zero-based chunk index.
+     */
+    readonly chunkIndex: number;
+    /**
+     * Optional classification result for this chunk.
+     */
+    readonly classificationResult?: ChunkClassificationResult;
+    /**
+     * Optional extraction result for this chunk.
+     */
+    readonly processingResult?: ChunkProcessingResult;
+    /**
+     * Error message if chunk processing failed.
+     */
+    readonly error?: string;
+}
+/**
+ * Extracted entity from document processing.
+ */
+export interface Entity {
+    /**
+     * Type of entity (e.g., 'NAME', 'DATE', 'AMOUNT', 'ADDRESS').
+     */
+    readonly type: string;
+    /**
+     * Value of the entity.
+     */
+    readonly value: string;
+    /**
+     * Optional page number where entity was found.
+     * Entities with page numbers are preserved even if duplicated.
+     */
+    readonly page?: number;
+    /**
+     * Optional chunk index where entity was found.
+     */
+    readonly chunkIndex?: number;
+}
+/**
+ * Request payload for aggregation Lambda.
+ * Contains results from all processed chunks.
+ */
+export interface AggregationRequest {
+    /**
+     * Document identifier.
+     */
+    readonly documentId: string;
+    /**
+     * Results from all processed chunks.
+     */
+    readonly chunkResults: ChunkResult[];
+    /**
+     * Strategy to use for aggregation.
+     * @default 'majority-vote'
+     */
+    readonly aggregationStrategy?: AggregationStrategy;
+}
+/**
+ * Summary of chunk processing results.
+ */
+export interface ChunksSummary {
+    /**
+     * Total number of chunks created.
+     */
+    readonly totalChunks: number;
+    /**
+     * Number of chunks that processed successfully.
+     */
+    readonly successfulChunks: number;
+    /**
+     * Number of chunks that failed processing.
+     */
+    readonly failedChunks: number;
+    /**
+     * Optional total tokens processed across all chunks.
+     */
+    readonly totalTokensProcessed?: number;
+}
+/**
+ * Aggregated result from processing all chunks.
+ * Combines classification and extraction results into final output.
+ */
+export interface AggregatedResult {
+    /**
+     * Document identifier.
+     */
+    readonly documentId: string;
+    /**
+     * Final document classification (from majority vote or other strategy).
+     */
+    readonly classification: string;
+    /**
+     * Confidence score for the classification (0-1).
+     * For majority vote: (count of majority / total chunks)
+     */
+    readonly classificationConfidence: number;
+    /**
+     * Deduplicated entities from all chunks.
+     * Entities without page numbers are deduplicated by (type, value).
+     * Entities with page numbers are preserved even if duplicated.
+     */
+    readonly entities: Entity[];
+    /**
+     * Summary of chunk processing results.
+     */
+    readonly chunksSummary: ChunksSummary;
+    /**
+     * Indicates if result is partial due to chunk failures.
+     * True if fewer than minSuccessThreshold chunks succeeded.
+     */
+    readonly partialResult: boolean;
+}
+/**
+ * Request payload for cleanup Lambda.
+ * Contains information about chunks to delete.
+ */
+export interface CleanupRequest {
+    /**
+     * Document identifier.
+     */
+    readonly documentId: string;
+    /**
+     * Array of chunk metadata for chunks to delete.
+     */
+    readonly chunks: ChunkMetadata[];
+}
+/**
+ * Response from cleanup Lambda.
+ * Reports success and any errors encountered.
+ */
+export interface CleanupResponse {
+    /**
+     * Document identifier.
+     */
+    readonly documentId: string;
+    /**
+     * Number of chunks successfully deleted.
+     */
+    readonly deletedChunks: number;
+    /**
+     * Array of error messages for failed deletions.
+     * Empty if all deletions succeeded.
+     */
+    readonly errors: string[];
+}

package/lib/document-processing/chunking-config.js

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chunking-config.js","sourceRoot":"","sources":["../../use-cases/document-processing/chunking-config.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,sCAAsC","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Chunking strategy options for PDF document processing.\n *\n * Choose the strategy based on your document characteristics:\n *\n * - **fixed-pages**: Legacy approach, splits by fixed page count.\n *   - Pros: Fast, simple, predictable chunk sizes\n *   - Cons: May exceed token limits for dense documents\n *   - Best for: Uniform density documents, simple text\n *\n * - **token-based**: Splits based on token count to respect model limits.\n *   - Pros: Respects model token limits, handles variable density\n *   - Cons: Slower analysis, variable chunk sizes\n *   - Best for: Variable density documents, technical content\n *\n * - **hybrid**: RECOMMENDED - Balances token count and page limits.\n *   - Pros: Best of both worlds, reliable, flexible\n *   - Cons: Slightly more complex configuration\n *   - Best for: Most documents, general-purpose processing\n */\nexport type ChunkingStrategy = 'fixed-pages' | 'token-based' | 'hybrid';\n\n/**\n * Processing mode for chunked documents.\n *\n * - **sequential**: Process chunks one at a time (cost-optimized)\n * - **parallel**: Process multiple chunks simultaneously (speed-optimized)\n */\nexport type ProcessingMode = 'sequential' | 'parallel';\n\n/**\n * Aggregation strategy for combining chunk results.\n *\n * - **majority-vote**: Select most frequent classification across chunks\n * - **weighted-vote**: Weight early chunks higher than later chunks\n * - **first-chunk**: Use classification from first chunk only\n */\nexport type AggregationStrategy = 'majority-vote' | 'weighted-vote' | 'first-chunk';\n\n/**\n * Configuration for fixed-pages chunking strategy.\n * Splits documents by fixed page count (legacy approach).\n */\nexport interface FixedPagesConfig {\n  /**\n   * Threshold for triggering chunking based on page count.\n   * Documents with pages > threshold will be chunked.\n   * @default 100\n   */\n  readonly pageThreshold?: number;\n\n  /**\n   * Number of pages per chunk.\n   * @default 50\n   */\n  readonly chunkSize?: number;\n\n  /**\n   * Number of overlapping pages between consecutive chunks.\n   * Must be less than chunkSize.\n   * @default 5\n   */\n  readonly overlapPages?: number;\n}\n\n/**\n * Configuration for token-based chunking strategy.\n * Splits documents based on estimated token count to respect model limits.\n */\nexport interface TokenBasedConfig {\n  /**\n   * Threshold for triggering chunking based on token count.\n   * Documents with tokens > threshold will be chunked.\n   * @default 150000\n   */\n  readonly tokenThreshold?: number;\n\n  /**\n   * Maximum tokens per chunk.\n   * Ensures no chunk exceeds model token limits.\n   * @default 100000\n   */\n  readonly maxTokensPerChunk?: number;\n\n  /**\n   * Number of overlapping tokens between consecutive chunks.\n   * Provides context continuity across chunks.\n   * @default 5000\n   */\n  readonly overlapTokens?: number;\n}\n\n/**\n * Configuration for hybrid chunking strategy (RECOMMENDED).\n * Balances token count and page limits for optimal chunking.\n */\nexport interface HybridConfig {\n  /**\n   * Hard limit on pages per chunk.\n   * Prevents very large chunks even if token count is low.\n   * Note: Bedrock has a hard limit of 100 pages per PDF, so we default to 99\n   * to provide a safety margin.\n   * @default 99\n   */\n  readonly maxPagesPerChunk?: number;\n\n  /**\n   * Soft target for tokens per chunk.\n   * Chunks aim for this token count but respect maxPagesPerChunk.\n   * @default 80000\n   */\n  readonly targetTokensPerChunk?: number;\n\n  /**\n   * Threshold for triggering chunking based on page count.\n   * Documents with pages > threshold will be chunked.\n   * @default 100\n   */\n  readonly pageThreshold?: number;\n\n  /**\n   * Threshold for triggering chunking based on token count.\n   * Documents with tokens > threshold will be chunked.\n   * @default 150000\n   */\n  readonly tokenThreshold?: number;\n\n  /**\n   * Number of overlapping tokens between consecutive chunks.\n   * Provides context continuity across chunks.\n   * @default 5000\n   */\n  readonly overlapTokens?: number;\n}\n\n/**\n * Comprehensive configuration for PDF chunking behavior.\n *\n * This interface provides fine-grained control over how large PDF documents are\n * split into manageable chunks for processing. The chunking system supports three\n * strategies, each optimized for different document types and use cases.\n *\n * ## Chunking Strategies\n *\n * ### 1. Hybrid Strategy (RECOMMENDED)\n * Balances both token count and page limits for optimal chunking. Best for most\n * documents as it respects model token limits while preventing excessively large chunks.\n *\n * ### 2. Token-Based Strategy\n * Splits documents based on estimated token count. Best for documents with variable\n * content density (e.g., mixed text and images, tables, charts).\n *\n * ### 3. Fixed-Pages Strategy (Legacy)\n * Simple page-based splitting. Fast but may exceed token limits for dense documents.\n * Use only for documents with uniform content density.\n *\n * ## Processing Modes\n *\n * - **parallel**: Process multiple chunks simultaneously (faster, higher cost)\n * - **sequential**: Process chunks one at a time (slower, lower cost)\n *\n * ## Aggregation Strategies\n *\n * - **majority-vote**: Most frequent classification wins (recommended)\n * - **weighted-vote**: Early chunks weighted higher\n * - **first-chunk**: Use first chunk's classification only\n *\n * ## Default Values\n *\n * | Parameter | Default | Description |\n * |-----------|---------|-------------|\n * | strategy | 'hybrid' | Chunking strategy |\n * | pageThreshold | 100 | Pages to trigger chunking |\n * | tokenThreshold | 150000 | Tokens to trigger chunking |\n * | chunkSize | 50 | Pages per chunk (fixed-pages) |\n * | overlapPages | 5 | Overlap pages (fixed-pages) |\n * | maxTokensPerChunk | 100000 | Max tokens per chunk (token-based) |\n * | overlapTokens | 5000 | Overlap tokens (token-based, hybrid) |\n * | targetTokensPerChunk | 80000 | Target tokens per chunk (hybrid) |\n * | maxPagesPerChunk | 99 | Max pages per chunk (hybrid) |\n * | processingMode | 'parallel' | Processing mode |\n * | maxConcurrency | 10 | Max parallel chunks |\n * | aggregationStrategy | 'majority-vote' | Result aggregation |\n * | minSuccessThreshold | 0.5 | Min success rate for valid result |\n */\nexport interface ChunkingConfig {\n  /**\n   * Chunking strategy to use.\n   *\n   * - **hybrid** (RECOMMENDED): Balances token count and page limits\n   * - **token-based**: Respects model token limits, good for variable density\n   * - **fixed-pages**: Simple page-based splitting (legacy, not recommended)\n   *\n   * @default 'hybrid'\n   */\n  readonly strategy?: ChunkingStrategy;\n\n  // Fixed-pages strategy configuration\n  /**\n   * Threshold for triggering chunking based on page count (fixed-pages strategy).\n   * @default 100\n   */\n  readonly pageThreshold?: number;\n\n  /**\n   * Number of pages per chunk (fixed-pages strategy).\n   * @default 50\n   */\n  readonly chunkSize?: number;\n\n  /**\n   * Number of overlapping pages between chunks (fixed-pages strategy).\n   * @default 5\n   */\n  readonly overlapPages?: number;\n\n  // Token-based strategy configuration\n  /**\n   * Threshold for triggering chunking based on token count (token-based strategy).\n   * @default 150000\n   */\n  readonly tokenThreshold?: number;\n\n  /**\n   * Maximum tokens per chunk (token-based strategy).\n   * @default 100000\n   */\n  readonly maxTokensPerChunk?: number;\n\n  /**\n   * Number of overlapping tokens between chunks (token-based and hybrid strategies).\n   * @default 5000\n   */\n  readonly overlapTokens?: number;\n\n  // Hybrid strategy configuration\n  /**\n   * Hard limit on pages per chunk (hybrid strategy).\n   * Note: Bedrock has a hard limit of 100 pages per PDF, so we default to 99\n   * to provide a safety margin.\n   * @default 99\n   */\n  readonly maxPagesPerChunk?: number;\n\n  /**\n   * Soft target for tokens per chunk (hybrid strategy).\n   * @default 80000\n   */\n  readonly targetTokensPerChunk?: number;\n\n  // Common settings\n  /**\n   * Processing mode for chunks.\n   *\n   * - **parallel**: Process multiple chunks simultaneously (faster, higher cost)\n   * - **sequential**: Process chunks one at a time (slower, lower cost)\n   *\n   * @default 'parallel'\n   */\n  readonly processingMode?: ProcessingMode;\n\n  /**\n   * Maximum number of chunks to process concurrently (parallel mode only).\n   * Higher values increase speed but also cost.\n   *\n   * @default 10\n   */\n  readonly maxConcurrency?: number;\n\n  /**\n   * Strategy for aggregating results from multiple chunks.\n   *\n   * - **majority-vote**: Most frequent classification wins\n   * - **weighted-vote**: Early chunks weighted higher\n   * - **first-chunk**: Use first chunk's classification\n   *\n   * @default 'majority-vote'\n   */\n  readonly aggregationStrategy?: AggregationStrategy;\n\n  /**\n   * Minimum percentage of chunks that must succeed for aggregation.\n   * If fewer chunks succeed, the result is marked as partial failure.\n   *\n   * @default 0.5 (50%)\n   */\n  readonly minSuccessThreshold?: number;\n}\n\n/**\n * Metadata about a single chunk of a document.\n * Contains information about the chunk's position, size, and S3 location.\n */\nexport interface ChunkMetadata {\n  /**\n   * Unique identifier for this chunk.\n   * Format: {documentId}_chunk_{index}\n   */\n  readonly chunkId: string;\n\n  /**\n   * Zero-based index of this chunk in the document.\n   */\n  readonly chunkIndex: number;\n\n  /**\n   * Total number of chunks in the document.\n   */\n  readonly totalChunks: number;\n\n  /**\n   * Starting page number (zero-based) of this chunk.\n   */\n  readonly startPage: number;\n\n  /**\n   * Ending page number (zero-based, inclusive) of this chunk.\n   */\n  readonly endPage: number;\n\n  /**\n   * Number of pages in this chunk.\n   */\n  readonly pageCount: number;\n\n  /**\n   * Estimated token count for this chunk.\n   * Based on word-count heuristic (1.3 tokens per word).\n   */\n  readonly estimatedTokens: number;\n\n  /**\n   * S3 bucket containing the chunk file.\n   */\n  readonly bucket: string;\n\n  /**\n   * S3 key for the chunk file.\n   * Typically in chunks/ prefix.\n   */\n  readonly key: string;\n}\n\n/**\n * Document content location information.\n */\nexport interface DocumentContent {\n  /**\n   * Storage location type (e.g., 's3').\n   */\n  readonly location: string;\n\n  /**\n   * S3 bucket containing the document.\n   */\n  readonly bucket: string;\n\n  /**\n   * S3 key for the document.\n   */\n  readonly key: string;\n\n  /**\n   * Original filename of the document.\n   */\n  readonly filename: string;\n}\n\n/**\n * Request payload for PDF analysis and chunking Lambda.\n * Contains document information and chunking configuration.\n */\nexport interface ChunkingRequest {\n  /**\n   * Unique identifier for the document.\n   */\n  readonly documentId: string;\n\n  /**\n   * Content type of the document.\n   * Typically 'file' for S3-based documents.\n   */\n  readonly contentType: string;\n\n  /**\n   * Document content location information.\n   */\n  readonly content: DocumentContent;\n\n  /**\n   * Optional chunking configuration.\n   * If not provided, uses default configuration.\n   */\n  readonly config?: ChunkingConfig;\n}\n\n/**\n * Token analysis results from PDF analysis.\n * Provides information about document size and token distribution.\n */\nexport interface TokenAnalysis {\n  /**\n   * Total estimated tokens in the document.\n   */\n  readonly totalTokens: number;\n\n  /**\n   * Total number of pages in the document.\n   */\n  readonly totalPages: number;\n\n  /**\n   * Average tokens per page across the document.\n   */\n  readonly avgTokensPerPage: number;\n\n  /**\n   * Optional detailed token count for each page.\n   * Used for token-based and hybrid chunking strategies.\n   */\n  readonly tokensPerPage?: number[];\n}\n\n/**\n * Response when chunking is NOT required.\n * Document is below thresholds and will be processed without chunking.\n */\nexport interface NoChunkingResponse {\n  /**\n   * Document identifier.\n   */\n  readonly documentId: string;\n\n  /**\n   * Indicates chunking is not required.\n   */\n  readonly requiresChunking: false;\n\n  /**\n   * Token analysis results.\n   */\n  readonly tokenAnalysis: TokenAnalysis;\n\n  /**\n   * Human-readable reason why chunking was not applied.\n   * Example: \"Document has 50 pages, below threshold of 100\"\n   */\n  readonly reason: string;\n}\n\n/**\n * Chunking configuration used for processing.\n * Includes both user-provided and default values.\n */\nexport interface ChunkingConfigUsed {\n  readonly strategy: ChunkingStrategy;\n  readonly totalPages: number;\n  readonly totalTokens: number;\n  readonly chunkSize?: number;\n  readonly overlapPages?: number;\n  readonly maxTokensPerChunk?: number;\n  readonly overlapTokens?: number;\n  readonly targetTokensPerChunk?: number;\n  readonly maxPagesPerChunk?: number;\n  readonly processingMode?: string;\n}\n\n/**\n * Response when chunking IS required.\n * Document exceeds thresholds and has been split into chunks.\n */\nexport interface ChunkingResponse {\n  /**\n   * Document identifier.\n   */\n  readonly documentId: string;\n\n  /**\n   * Indicates chunking is required.\n   */\n  readonly requiresChunking: true;\n\n  /**\n   * Token analysis results with detailed per-page information.\n   */\n  readonly tokenAnalysis: TokenAnalysis;\n\n  /**\n   * Strategy used for chunking.\n   */\n  readonly strategy: ChunkingStrategy;\n\n  /**\n   * Array of chunk metadata for all created chunks.\n   */\n  readonly chunks: ChunkMetadata[];\n\n  /**\n   * Configuration used for chunking.\n   * Includes both user-provided and default values.\n   */\n  readonly config: ChunkingConfigUsed;\n}\n\n/**\n * Union type for chunking Lambda response.\n * Either chunking is required or not.\n */\nexport type ChunkingLambdaResponse = NoChunkingResponse | ChunkingResponse;\n\n/**\n * Classification result for a chunk.\n */\nexport interface ChunkClassificationResult {\n  readonly documentClassification: string;\n  readonly confidence?: number;\n}\n\n/**\n * Processing result for a chunk.\n */\nexport interface ChunkProcessingResult {\n  readonly entities: Entity[];\n}\n\n/**\n * Result from processing a single chunk.\n * Contains classification and extraction results, or error information.\n */\nexport interface ChunkResult {\n  /**\n   * Chunk identifier.\n   */\n  readonly chunkId: string;\n\n  /**\n   * Zero-based chunk index.\n   */\n  readonly chunkIndex: number;\n\n  /**\n   * Optional classification result for this chunk.\n   */\n  readonly classificationResult?: ChunkClassificationResult;\n\n  /**\n   * Optional extraction result for this chunk.\n   */\n  readonly processingResult?: ChunkProcessingResult;\n\n  /**\n   * Error message if chunk processing failed.\n   */\n  readonly error?: string;\n}\n\n/**\n * Extracted entity from document processing.\n */\nexport interface Entity {\n  /**\n   * Type of entity (e.g., 'NAME', 'DATE', 'AMOUNT', 'ADDRESS').\n   */\n  readonly type: string;\n\n  /**\n   * Value of the entity.\n   */\n  readonly value: string;\n\n  /**\n   * Optional page number where entity was found.\n   * Entities with page numbers are preserved even if duplicated.\n   */\n  readonly page?: number;\n\n  /**\n   * Optional chunk index where entity was found.\n   */\n  readonly chunkIndex?: number;\n}\n\n/**\n * Request payload for aggregation Lambda.\n * Contains results from all processed chunks.\n */\nexport interface AggregationRequest {\n  /**\n   * Document identifier.\n   */\n  readonly documentId: string;\n\n  /**\n   * Results from all processed chunks.\n   */\n  readonly chunkResults: ChunkResult[];\n\n  /**\n   * Strategy to use for aggregation.\n   * @default 'majority-vote'\n   */\n  readonly aggregationStrategy?: AggregationStrategy;\n}\n\n/**\n * Summary of chunk processing results.\n */\nexport interface ChunksSummary {\n  /**\n   * Total number of chunks created.\n   */\n  readonly totalChunks: number;\n\n  /**\n   * Number of chunks that processed successfully.\n   */\n  readonly successfulChunks: number;\n\n  /**\n   * Number of chunks that failed processing.\n   */\n  readonly failedChunks: number;\n\n  /**\n   * Optional total tokens processed across all chunks.\n   */\n  readonly totalTokensProcessed?: number;\n}\n\n/**\n * Aggregated result from processing all chunks.\n * Combines classification and extraction results into final output.\n */\nexport interface AggregatedResult {\n  /**\n   * Document identifier.\n   */\n  readonly documentId: string;\n\n  /**\n   * Final document classification (from majority vote or other strategy).\n   */\n  readonly classification: string;\n\n  /**\n   * Confidence score for the classification (0-1).\n   * For majority vote: (count of majority / total chunks)\n   */\n  readonly classificationConfidence: number;\n\n  /**\n   * Deduplicated entities from all chunks.\n   * Entities without page numbers are deduplicated by (type, value).\n   * Entities with page numbers are preserved even if duplicated.\n   */\n  readonly entities: Entity[];\n\n  /**\n   * Summary of chunk processing results.\n   */\n  readonly chunksSummary: ChunksSummary;\n\n  /**\n   * Indicates if result is partial due to chunk failures.\n   * True if fewer than minSuccessThreshold chunks succeeded.\n   */\n  readonly partialResult: boolean;\n}\n\n/**\n * Request payload for cleanup Lambda.\n * Contains information about chunks to delete.\n */\nexport interface CleanupRequest {\n  /**\n   * Document identifier.\n   */\n  readonly documentId: string;\n\n  /**\n   * Array of chunk metadata for chunks to delete.\n   */\n  readonly chunks: ChunkMetadata[];\n}\n\n/**\n * Response from cleanup Lambda.\n * Reports success and any errors encountered.\n */\nexport interface CleanupResponse {\n  /**\n   * Document identifier.\n   */\n  readonly documentId: string;\n\n  /**\n   * Number of chunks successfully deleted.\n   */\n  readonly deletedChunks: number;\n\n  /**\n   * Array of error messages for failed deletions.\n   * Empty if all deletions succeeded.\n   */\n  readonly errors: string[];\n}\n"]}

package/lib/document-processing/default-document-processing-config.js

@@ -9,6 +9,6 @@ class DefaultDocumentProcessingConfig {
 }
 exports.DefaultDocumentProcessingConfig = DefaultDocumentProcessingConfig;
 _a = JSII_RTTI_SYMBOL_1;
-DefaultDocumentProcessingConfig[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.DefaultDocumentProcessingConfig", version: "1.5.0" };
+DefaultDocumentProcessingConfig[_a] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.DefaultDocumentProcessingConfig", version: "1.6.0" };
 DefaultDocumentProcessingConfig.DEFAULT_OBSERVABILITY_METRIC_SVC_NAME = 'document-processing';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1kb2N1bWVudC1wcm9jZXNzaW5nLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3VzZS1jYXNlcy9kb2N1bWVudC1wcm9jZXNzaW5nL2RlZmF1bHQtZG9jdW1lbnQtcHJvY2Vzc2luZy1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxxRUFBcUU7QUFDckUsc0NBQXNDO0FBRXRDLE1BQWEsK0JBQStCOztBQUE1QywwRUFFQzs7O0FBRHdCLHFFQUFxQyxHQUFHLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IEFtYXpvbi5jb20sIEluYy4gb3IgaXRzIGFmZmlsaWF0ZXMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgY2xhc3MgRGVmYXVsdERvY3VtZW50UHJvY2Vzc2luZ0NvbmZpZyB7XG4gIHB1YmxpYyBzdGF0aWMgcmVhZG9ubHkgREVGQVVMVF9PQlNFUlZBQklMSVRZX01FVFJJQ19TVkNfTkFNRSA9ICdkb2N1bWVudC1wcm9jZXNzaW5nJztcbn0iXX0=

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

@@ -3,3 +3,4 @@ export * from './bedrock-document-processing';
 export * from './agentic-document-processing';
 export * from './adapter';
 export * from './default-document-processing-config';
+export * from './chunking-config';