Update AWS SDK dependencies and enhance AwsBedrockService for improved model handling and image processing capabilities

Add a controller for testing AwsBedrockService

Author: adamrefaey

backend/package-lock.json

@@ -27,6 +27,7 @@
     "cdk:synth": "dotenv -- npx cdk synth"
   },
   "dependencies": {
+    "@aws-sdk/client-bedrock": "^3.782.0",
     "@aws-sdk/client-bedrock-runtime": "^3.782.0",
     "@aws-sdk/client-dynamodb": "^3.758.0",
     "@aws-sdk/client-secrets-manager": "^3.758.0",

backend/package.json

@@ -1,4 +1,4 @@
-import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
+import { Module, NestModule, MiddlewareConsumer, RequestMethod } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import configuration from './config/configuration';
 import { AppController } from './app.controller';
@@ -11,6 +11,8 @@ import { UserController } from './user/user.controller';
 import { ReportsModule } from './reports/reports.module';
 import { HealthController } from './health/health.controller';
 import { AuthMiddleware } from './auth/auth.middleware';
+import { BedrockTestModule } from './controllers/bedrock/bedrock.module';
+import { BedrockTestController } from './controllers/bedrock/bedrock-test.controller';
 
 @Module({
   imports: [
@@ -19,12 +21,27 @@ import { AuthMiddleware } from './auth/auth.middleware';
       load: [configuration],
     }),
     ReportsModule,
+    BedrockTestModule,
+  ],
+  controllers: [
+    AppController,
+    BedrockTestController,
+    HealthController,
+    PerplexityController,
+    UserController,
   ],
-  controllers: [AppController, HealthController, PerplexityController, UserController],
   providers: [AppService, AwsSecretsService, AwsBedrockService, PerplexityService],
 })
 export class AppModule implements NestModule {
   configure(consumer: MiddlewareConsumer) {
-    consumer.apply(AuthMiddleware).forRoutes('*'); // Apply to all routes
+    consumer
+      .apply(AuthMiddleware)
+      .exclude(
+        { path: 'test-bedrock', method: RequestMethod.GET },
+        { path: 'test-bedrock/health', method: RequestMethod.GET },
+        { path: 'test-bedrock/extract-medical-info', method: RequestMethod.POST },
+        { path: 'health', method: RequestMethod.GET },
+      )
+      .forRoutes('*');
   }
 }

backend/src/app.module.ts

@@ -4,11 +4,11 @@ import configuration from './configuration';
 describe('Configuration', () => {
   // Save original environment
   const originalEnv = { ...process.env };
-  
+
   beforeEach(() => {
     // Clear environment variables before each test
     process.env = {};
-    
+
     // Set NODE_ENV to test for the first test
     process.env.NODE_ENV = 'test';
   });
@@ -20,7 +20,7 @@ describe('Configuration', () => {
 
   it('should return default values when no env variables are set', () => {
     const config = configuration();
-    
+
     expect(config.port).toBe(3000);
     expect(config.environment).toBe('test');
     expect(config.aws.region).toBe('us-east-1'); // Default value in configuration.ts
@@ -50,4 +50,4 @@ describe('Configuration', () => {
     delete process.env.AWS_COGNITO_USER_POOL_ID;
     delete process.env.AWS_COGNITO_CLIENT_ID;
   });
-}); 
+});

backend/src/config/configuration.spec.ts

@@ -8,16 +8,22 @@ export default () => ({
       clientId: process.env.AWS_COGNITO_CLIENT_ID,
     },
     secretsManager: {
-      perplexityApiKeySecret: process.env.PERPLEXITY_API_KEY_SECRET_NAME || 'medical-reports-explainer/perplexity-api-key',
+      perplexityApiKeySecret:
+        process.env.PERPLEXITY_API_KEY_SECRET_NAME ||
+        'medical-reports-explainer/perplexity-api-key',
     },
     aws: {
       accessKeyId: process.env.AWS_ACCESS_KEY_ID,
       secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      sessionToken: process.env.AWS_SESSION_TOKEN,
     },
     bedrock: {
-      model: process.env.AWS_BEDROCK_MODEL || 'anthropic.claude-3-7-sonnet-20250219-v1:0',
+      model: process.env.AWS_BEDROCK_MODEL || 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
       maxTokens: parseInt(process.env.AWS_BEDROCK_MAX_TOKENS || '2048', 10),
-    }
+      inferenceProfileArn:
+        process.env.AWS_BEDROCK_INFERENCE_PROFILE_ARN ||
+        'arn:aws:bedrock:us-east-1:841162674562:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    },
   },
   perplexity: {
     apiBaseUrl: 'https://api.perplexity.ai',

backend/src/config/configuration.ts

@@ -0,0 +1,88 @@
+# AWS Bedrock Test Controller
+
+This controller provides a testing interface for the AWS Bedrock medical image analysis service, bypassing authentication for easy testing and debugging.
+
+## Features
+
+- Extracts medical information from images using AWS Bedrock AI service
+- Handles image uploads via a simple HTML interface
+- Processes JPEG, PNG, and HEIC/HEIF images
+- Automatic image compression for files over 2MB
+- No authentication required (for testing purposes only)
+
+## How to Use
+
+### Web Interface
+
+1. Start your NestJS server
+2. Visit `http://localhost:YOUR_PORT/api/test-bedrock` in your browser
+3. Upload a medical image using the provided form
+4. Click "Analyze Medical Image" to process the image
+5. View the JSON response with extracted medical information
+
+### File Size Limits
+
+- **Maximum file size**: 2MB
+- Images larger than 2MB will be automatically compressed:
+  - First by reducing image quality
+  - Then by reducing dimensions if needed
+  - Converted to WebP format for better compression
+
+### API Endpoint
+
+You can also directly call the API endpoint programmatically:
+
+```bash
+curl -X POST http://localhost:YOUR_PORT/api/test-bedrock/extract-medical-info \
+  -H "Content-Type: application/json" \
+  -d '{
+    "base64Image": "YOUR_BASE64_ENCODED_IMAGE_HERE",
+    "contentType": "image/jpeg",
+    "filename": "optional_filename.jpg"
+  }'
+```
+
+## Response Format
+
+The API returns a structured JSON response with the following sections:
+
+- `keyMedicalTerms`: Array of medical terms and their definitions
+- `labValues`: Array of lab values with units and normal ranges
+- `diagnoses`: Array of diagnoses with details and recommendations
+- `metadata`: Information about the confidence and any missing information
+
+## Security Considerations
+
+This controller is intended for **testing purposes only** and bypasses authentication mechanisms. Do not use in production environments without proper security measures.
+
+## Troubleshooting
+
+### Common Errors
+
+#### "Request entity too large"
+
+This error occurs when the request body exceeds the server's size limit. To resolve:
+
+1. Use the web interface which automatically compresses large images
+2. Manually compress your image to under 2MB before uploading
+3. Use lower resolution images that contain clear text
+4. Convert to WebP format for better compression ratio
+
+#### "File content appears to be encrypted or compressed"
+
+This error occurs when AWS Bedrock cannot properly process the image format. To resolve:
+
+1. Try a different image format (PNG often works better than JPEG)
+2. Ensure the image is not encrypted or password protected
+3. Take a new photo with better lighting and clarity
+4. Avoid screenshots of PDFs - use the original document
+5. Make sure the image is not heavily compressed
+
+#### General Tips
+
+- Ensure your AWS Bedrock credentials are properly configured
+- Use clear, high-quality images of medical documents
+- Check that uploaded images are in supported formats (JPEG, PNG, HEIC/HEIF)
+- Verify the image contains medical information (lab reports, prescriptions, etc.)
+- Make sure text is readable in the image
+- Avoid cropped or partial images 

backend/src/controllers/bedrock/README.md

@@ -0,0 +1,50 @@
+import { Controller, Get, HttpCode, HttpStatus, BadRequestException } from '@nestjs/common';
+import { Logger } from '@nestjs/common';
+import { AwsBedrockService } from '../../services/aws-bedrock.service';
+
+@Controller('api/test-bedrock')
+export class BedrockTestController {
+  private readonly logger = new Logger(BedrockTestController.name);
+
+  constructor(private readonly awsBedrockService: AwsBedrockService) {}
+
+  @Get('list-models')
+  @HttpCode(HttpStatus.OK)
+  async listModels(): Promise<any> {
+    try {
+      this.logger.log('Requesting available Bedrock models');
+
+      // Get the list of models from the AWS Bedrock service
+      const models = await this.awsBedrockService.listAvailableModels();
+
+      // Get current model information directly from the service instance
+      const currentModel = {
+        modelId: this.awsBedrockService['modelId'], // Access the modelId property
+        inferenceProfileArn: this.awsBedrockService['inferenceProfileArn'], // Access the inferenceProfileArn property if it exists
+      };
+
+      return {
+        status: 'success',
+        currentModel,
+        models,
+      };
+    } catch (error: unknown) {
+      this.logger.error('Error listing Bedrock models', {
+        error: error instanceof Error ? error.message : 'Unknown error',
+      });
+      throw new BadRequestException(
+        `Failed to list Bedrock models: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      );
+    }
+  }
+
+  @Get('health')
+  @HttpCode(HttpStatus.OK)
+  async checkHealth(): Promise<any> {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      service: 'aws-bedrock',
+    };
+  }
+}

backend/src/controllers/bedrock/bedrock-test.controller.ts

@@ -0,0 +1,121 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { HttpException } from '@nestjs/common';
+import { BedrockTestController } from './bedrock.controller';
+import { AwsBedrockService } from '../../services/aws-bedrock.service';
+import { UploadMedicalImageDto } from './bedrock.dto';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+describe('BedrockTestController', () => {
+  let controller: BedrockTestController;
+  let bedrockService: AwsBedrockService;
+
+  // Mock data
+  const mockBase64Image = 'R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'; // 1x1 transparent GIF
+  const mockContentType = 'image/jpeg';
+  const mockMedicalInfo = {
+    keyMedicalTerms: [
+      { term: 'Hemoglobin', definition: 'Protein in red blood cells that carries oxygen' },
+    ],
+    labValues: [
+      {
+        name: 'Hemoglobin',
+        value: '14.5',
+        unit: 'g/dL',
+        normalRange: '12.0-15.5',
+        isAbnormal: false,
+      },
+    ],
+    diagnoses: [
+      {
+        condition: 'Normal Blood Count',
+        details: 'All values within normal range',
+        recommendations: 'Continue routine monitoring',
+      },
+    ],
+    metadata: {
+      isMedicalReport: true,
+      confidence: 0.95,
+      missingInformation: [],
+    },
+  };
+
+  beforeEach(async () => {
+    // Create mock service with spy for extractMedicalInfo
+    const mockBedrockService = {
+      extractMedicalInfo: vi.fn().mockResolvedValue(mockMedicalInfo),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [BedrockTestController],
+      providers: [
+        {
+          provide: AwsBedrockService,
+          useValue: mockBedrockService,
+        },
+      ],
+    }).compile();
+
+    controller = module.get<BedrockTestController>(BedrockTestController);
+    bedrockService = module.get<AwsBedrockService>(AwsBedrockService);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('extractMedicalInfo', () => {
+    it('should extract medical information from a valid image', async () => {
+      // Prepare DTO
+      const dto: UploadMedicalImageDto = {
+        base64Image: mockBase64Image,
+        contentType: mockContentType,
+        filename: 'test.jpg',
+      };
+
+      // Mock request object
+      const mockRequest = {
+        ip: '127.0.0.1',
+        connection: { remoteAddress: '127.0.0.1' },
+      };
+
+      // Call the controller method
+      const result = await controller.extractMedicalInfo(dto, mockRequest as any);
+
+      // Verify service was called with correct parameters
+      expect(bedrockService.extractMedicalInfo).toHaveBeenCalledWith(
+        expect.any(Buffer),
+        mockContentType,
+        '127.0.0.1',
+      );
+
+      // Verify result
+      expect(result).toEqual(mockMedicalInfo);
+      expect(result.keyMedicalTerms[0].term).toBe('Hemoglobin');
+      expect(result.metadata.isMedicalReport).toBe(true);
+    });
+
+    it('should handle errors from the service', async () => {
+      // Prepare DTO
+      const dto: UploadMedicalImageDto = {
+        base64Image: mockBase64Image,
+        contentType: mockContentType,
+      };
+
+      // Mock request object
+      const mockRequest = {
+        ip: '127.0.0.1',
+        connection: { remoteAddress: '127.0.0.1' },
+      };
+
+      // Mock service error
+      vi.spyOn(bedrockService, 'extractMedicalInfo').mockRejectedValueOnce(
+        new HttpException('Invalid image format', 400),
+      );
+
+      // Test error handling
+      await expect(controller.extractMedicalInfo(dto, mockRequest as any)).rejects.toThrow(
+        HttpException,
+      );
+    });
+  });
+});