Update to Claude 3 & Dynamic Prompt Management

Integrated AWS SSM for dynamic prompt management, replacing static prompts in BedrockSummaryService with a new PromptService. Updated to use Anthropic's Claude 3 Sonnet model, adjusting payload and response parsing. Enhanced dependency injection and logging. Added IPromptService interface and improved error handling. Updated project dependencies.

Author: SashveerRamjathan

Function.cs

@@ -9,6 +9,7 @@
 using Sqs_AI_Lambda.Models;
 using Sqs_AI_Lambda.Services;
 using System.Text.Json;
+using Amazon.SimpleSystemsManagement;
 
 // Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
 [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
@@ -92,14 +93,16 @@ private static ServiceProvider ConfigureServices()
             builder.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Information);
         });
 
-        // Register AWS SQS client with default configuration for Lambda environment
+        // Register AWS Service Clients as Singletons
         services.AddSingleton<IAmazonSQS>(provider => new AmazonSQSClient());
         services.AddSingleton<AmazonBedrockRuntimeClient>(provider => new AmazonBedrockRuntimeClient());
+        services.AddSingleton<IAmazonSimpleSystemsManagement>(provider => new AmazonSimpleSystemsManagementClient());
 
         // Register application services as transient for per-invocation isolation
         services.AddTransient<ISqsService, SqsService>();
         services.AddTransient<IMessageProcessor, MessageProcessor>();
         services.AddTransient<IMessageFactory, MessageFactory>();
+        services.AddSingleton<IPromptService, PromptService>();
         services.AddTransient<IBedrockSummaryService, BedrockSummaryService>();
 
         return services.BuildServiceProvider();

Interfaces/IPromptService.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Sqs_AI_Lambda.Interfaces
+{
+    /// <summary>
+    /// Defines the contract for a service that retrieves Bedrock prompts,
+    /// potentially caching them for performance.
+    /// </summary>
+    public interface IPromptService
+    {
+        /// <summary>
+        /// Retrieves the combined system and source-specific prompt for a given tender source type.
+        /// Fetches prompts from AWS Parameter Store and caches them locally.
+        /// </summary>
+        /// <param name="sourceType">The specific tender source (e.g., "Eskom", "SARS").</param>
+        /// <returns>The combined prompt string to be used with Bedrock.</returns>
+        /// <exception cref="ArgumentException">Thrown if sourceType is null or empty.</exception>
+        /// <exception cref="KeyNotFoundException">Thrown if a required prompt parameter is not found in Parameter Store.</exception>
+        Task<string> GetPromptAsync(string sourceType);
+    }
+}

Services/BedrockSummaryService.cs

@@ -14,39 +14,27 @@
 namespace Sqs_AI_Lambda.Services
 {
     /// <summary>
-    /// Service for generating AI-powered tender summaries using AWS Bedrock
-    /// Enhanced with retry logic, rate limiting, and robust error handling for production use
+    /// Service for generating AI-powered tender summaries using AWS Bedrock.
+    /// It now dynamically fetches prompts from a dedicated prompt service.
+    /// It now uses Anthropic's Claude 3 Sonnet model.
     /// </summary>
     public class BedrockSummaryService : IBedrockSummaryService
     {
         private readonly ILogger<BedrockSummaryService> _logger;
         private readonly AmazonBedrockRuntimeClient _bedrockClient;
+        private readonly IPromptService _promptService;
 
         // Rate limiting and retry configuration
         private static readonly SemaphoreSlim _rateLimitSemaphore = new(3, 3); // Max 3 concurrent requests
         private const int MaxRetryAttempts = 5;
         private const int BaseDelayMs = 1000; // 1 second base delay
 
-        private const string SystemPrompt = @"You are a professional tender analyst. 
-            Analyse the tender data and create a structured summary with these sections:
-
-            **PURPOSE:** What the tender is for and scope
-            **ELIGIBILITY:** Who can apply and requirements  
-            **APPLICATION:** How to apply, deadlines, procedures
-            **LOCATION/CONTACT:** Location details and contact info
-            **DOCUMENTS:** Required/supporting documents
-            **DETAILS:** Other important information
-
-            Guidelines:
-            - Use only provided information
-            - State Information not provided for missing info
-            - Be concise but comprehensive
-            - Use bullet points for clarity";
-
-        public BedrockSummaryService(ILogger<BedrockSummaryService> logger, AmazonBedrockRuntimeClient bedrockClient)
+        
+        public BedrockSummaryService(ILogger<BedrockSummaryService> logger, AmazonBedrockRuntimeClient bedrockClient, IPromptService promptService)
         {
             _logger = logger;
             _bedrockClient = bedrockClient;
+            _promptService = promptService;
         }
 
         /// <summary>
@@ -59,33 +47,37 @@ public async Task<string> GenerateSummaryAsync(TenderMessageBase tenderMessage)
             var tenderNumber = tenderMessage.TenderNumber ?? "Unknown";
             var sourceType = tenderMessage.GetSourceType();
 
-            _logger.LogInformation("Starting Nova Pro summary with rate limiting - TenderNumber: {TenderNumber}, Source: {SourceType}",
+            _logger.LogInformation("Starting summary generation - TenderNumber: {TenderNumber}, Source: {SourceType}",
                 tenderNumber, sourceType);
 
             // Wait for rate limit semaphore to control concurrent requests
             await _rateLimitSemaphore.WaitAsync();
 
             try
             {
+                // Fetch the dynamic, combined prompt for the specific source
+                var combinedPrompt = await _promptService.GetPromptAsync(sourceType);
+
                 // Convert to compact JSON format to minimize tokens
                 var tenderJson = ConvertTenderToCompactJson(tenderMessage);
 
                 _logger.LogDebug("Tender JSON created - TenderNumber: {TenderNumber}, JsonLength: {JsonLength}",
                     tenderNumber, tenderJson.Length);
 
-                // Execute with retry logic for handling throttling
-                var summary = await ExecuteWithRetryAsync(tenderJson, tenderNumber);
+                // Pass the combined prompt to the execution method
+                var summary = await ExecuteWithRetryAsync(combinedPrompt, tenderJson, tenderNumber);
 
                 var duration = (DateTime.UtcNow - startTime).TotalMilliseconds;
-                _logger.LogInformation("Nova Pro summary completed successfully - TenderNumber: {TenderNumber}, Duration: {Duration}ms, Length: {Length}",
-                    tenderNumber, duration, summary.Length);
+
+                _logger.LogInformation("Summary completed successfully - TenderNumber: {TenderNumber}, Duration: {Duration}ms",
+                    tenderNumber, duration);
 
                 return summary;
             }
             catch (Exception ex)
             {
                 var duration = (DateTime.UtcNow - startTime).TotalMilliseconds;
-                _logger.LogError(ex, "Nova Pro summary failed after all retries - TenderNumber: {TenderNumber}, Duration: {Duration}ms, ErrorType: {ErrorType}",
+                _logger.LogError(ex, "Summary generation failed after all retries - TenderNumber: {TenderNumber}, Duration: {Duration}ms, ErrorType: {ErrorType}",
                     tenderNumber, duration, ex.GetType().Name);
 
                 return GenerateFallbackSummary(tenderMessage);
@@ -98,9 +90,9 @@ public async Task<string> GenerateSummaryAsync(TenderMessageBase tenderMessage)
         }
 
         /// <summary>
-        /// Executes Bedrock request with exponential backoff retry logic for handling throttling
+        /// Executes Bedrock request with retry logic, now using a dynamic prompt.
         /// </summary>
-        private async Task<string> ExecuteWithRetryAsync(string tenderJson, string tenderNumber)
+        private async Task<string> ExecuteWithRetryAsync(string combinedPrompt, string tenderJson, string tenderNumber)
         {
             var attempt = 0;
 
@@ -113,9 +105,12 @@ private async Task<string> ExecuteWithRetryAsync(string tenderJson, string tende
                     _logger.LogDebug("Bedrock request attempt {Attempt}/{MaxAttempts} - TenderNumber: {TenderNumber}",
                         attempt, MaxRetryAttempts, tenderNumber);
 
-                    // Optimised payload for token efficiency
+                    // Payload structured for Anthropic Claude 3 models
                     var payload = new
                     {
+                        anthropic_version = "bedrock-2023-05-31", // Required for Claude 3
+                        max_tokens = 900,
+                        temperature = 0.3,
                         messages = new[]
                         {
                             new
@@ -125,22 +120,17 @@ private async Task<string> ExecuteWithRetryAsync(string tenderJson, string tende
                                 {
                                     new
                                     {
-                                        text = $"{SystemPrompt}\n\nTender: {tenderJson}"
+                                        type = "text",
+                                        text = $"{combinedPrompt}\n\nTender Data:\n{tenderJson}"
                                     }
                                 }
                             }
-                        },
-                        inferenceConfig = new
-                        {
-                            max_new_tokens = 800,    // Efficient token usage
-                            temperature = 0.3,       // Low for consistent output
-                            top_p = 0.9
                         }
                     };
 
                     var request = new InvokeModelRequest
                     {
-                        ModelId = "amazon.nova-pro-v1:0",
+                        ModelId = "anthropic.claude-3-sonnet-20240229-v1:0", // Model ID changed to Claude 3 Sonnet
                         ContentType = "application/json",
                         Accept = "application/json",
                         Body = new MemoryStream(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(payload)))
@@ -151,7 +141,8 @@ private async Task<string> ExecuteWithRetryAsync(string tenderJson, string tende
                     using var responseStream = new StreamReader(response.Body);
                     var responseText = await responseStream.ReadToEndAsync();
 
-                    var summary = ParseNovaResponse(responseText);
+                    // Call the new response parser for Claude
+                    var summary = ParseClaudeResponse(responseText);
 
                     _logger.LogDebug("Bedrock request successful on attempt {Attempt} - TenderNumber: {TenderNumber}",
                         attempt, tenderNumber);
@@ -361,7 +352,7 @@ private void AddSanralSpecificFields(Dictionary<string, object> compactTender, S
         }
 
         /// <summary>
-        /// Parses Amazon Nova Pro's response to extract the summary content
+        /// Parses Amazon Nova's response to extract the summary content
         /// </summary>
         private string ParseNovaResponse(string responseJson)
         {
@@ -393,6 +384,38 @@ private string ParseNovaResponse(string responseJson)
             }
         }
 
+
+        /// <summary>
+        /// Parses the JSON response from an Anthropic Claude 3 model to extract the summary content.
+        /// </summary>
+        private string ParseClaudeResponse(string responseJson)
+        {
+            try
+            {
+                using var document = JsonDocument.Parse(responseJson);
+                var contentArray = document.RootElement.GetProperty("content");
+
+                if (contentArray.ValueKind == JsonValueKind.Array)
+                {
+                    foreach (var contentItem in contentArray.EnumerateArray())
+                    {
+                        if (contentItem.TryGetProperty("type", out var typeProperty) && typeProperty.GetString() == "text" &&
+                            contentItem.TryGetProperty("text", out var textProperty))
+                        {
+                            return textProperty.GetString() ?? "Summary generated but content extraction failed.";
+                        }
+                    }
+                }
+                _logger.LogWarning("Unexpected Claude 3 response format: 'text' field not found in content array.");
+                return "Summary generated but response parsing failed (unexpected format).";
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to parse Claude 3 response JSON: {ResponseJson}", responseJson);
+                return "Summary generation completed but response parsing failed (exception).";
+            }
+        }
+
         /// <summary>
         /// Generates a model-aware fallback summary when Bedrock fails
         /// Enhanced with throttling context information

Services/PromptService.cs

@@ -0,0 +1,111 @@
+using Amazon.SimpleSystemsManagement;
+using Amazon.SimpleSystemsManagement.Model;
+using Microsoft.Extensions.Logging;
+using Sqs_AI_Lambda.Interfaces;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Sqs_AI_Lambda.Services
+{
+    /// <summary>
+    /// Service responsible for fetching and caching Bedrock prompts from AWS Parameter Store.
+    /// Uses a static cache to minimize API calls during warm Lambda invocations.
+    /// </summary>
+    public class PromptService : IPromptService
+    {
+        private readonly IAmazonSimpleSystemsManagement _ssmClient;
+        private readonly ILogger<PromptService> _logger;
+
+        // Base path for prompt parameters in Parameter Store
+        private const string PromptBasePath = "/TenderSummary/Prompts/";
+        private const string SystemPromptKey = "System"; // Special key for the system prompt
+
+        // Static cache using ConcurrentDictionary for thread safety during parallel fetches if needed
+        private static readonly ConcurrentDictionary<string, string> _promptCache = new();
+
+        public PromptService(IAmazonSimpleSystemsManagement ssmClient, ILogger<PromptService> logger)
+        {
+            _ssmClient = ssmClient ?? throw new ArgumentNullException(nameof(ssmClient));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }
+
+        /// <inheritdoc/>
+        public async Task<string> GetPromptAsync(string sourceType)
+        {
+            if (string.IsNullOrWhiteSpace(sourceType))
+            {
+                throw new ArgumentException("Source type cannot be null or empty.", nameof(sourceType));
+            }
+
+            // Ensure System prompt is cached
+            string systemPrompt = await EnsurePromptCachedAsync(SystemPromptKey);
+
+            // Ensure source-specific prompt is cached
+            string sourcePrompt = await EnsurePromptCachedAsync(sourceType);
+
+            // Combine prompts
+            string combinedPrompt = $"{systemPrompt}\n\n{sourcePrompt}";
+
+            _logger.LogDebug("Combined prompt retrieved for source type: {SourceType}", sourceType);
+            return combinedPrompt;
+        }
+
+        /// <summary>
+        /// Helper method to fetch a specific prompt from cache or Parameter Store.
+        /// </summary>
+        /// <param name="promptKey">The key of the prompt (e.g., "System", "Eskom").</param>
+        /// <returns>The prompt text.</returns>
+        private async Task<string> EnsurePromptCachedAsync(string promptKey)
+        {
+            // Check cache first (case-insensitive key comparison)
+            if (_promptCache.TryGetValue(promptKey, out var cachedPrompt))
+            {
+                _logger.LogDebug("Prompt found in cache for key: {PromptKey}", promptKey);
+                return cachedPrompt;
+            }
+
+            // Construct the full parameter name
+            string parameterName = $"{PromptBasePath}{promptKey}";
+            _logger.LogInformation("Prompt not found in cache for key: {PromptKey}. Fetching from Parameter Store: {ParameterName}", promptKey, parameterName);
+
+            try
+            {
+                var request = new GetParameterRequest
+                {
+                    Name = parameterName,
+                    WithDecryption = false
+                };
+
+                var response = await _ssmClient.GetParameterAsync(request);
+
+                if (response.Parameter == null || string.IsNullOrEmpty(response.Parameter.Value))
+                {
+                    _logger.LogError("Parameter {ParameterName} was found but has no value.", parameterName);
+                    throw new KeyNotFoundException($"Parameter '{parameterName}' retrieved from Parameter Store has no value.");
+                }
+
+                string promptValue = response.Parameter.Value;
+
+                // Add to cache
+                _promptCache.AddOrUpdate(promptKey, promptValue, (key, oldValue) => promptValue);
+
+                _logger.LogInformation("Successfully fetched and cached prompt for key: {PromptKey}", promptKey);
+                return promptValue;
+            }
+            catch (ParameterNotFoundException ex)
+            {
+                _logger.LogError(ex, "Required prompt parameter not found in Parameter Store: {ParameterName}", parameterName);
+                throw new KeyNotFoundException($"Required prompt parameter '{parameterName}' not found in AWS Parameter Store.", ex);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to fetch parameter {ParameterName} from Parameter Store.", parameterName);
+                throw;
+            }
+        }
+    }
+}

Sqs_AI_Lambda.csproj

@@ -15,6 +15,7 @@
     <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="2.4.4" />
     <PackageReference Include="Amazon.Lambda.SQSEvents" Version="2.2.0" />
     <PackageReference Include="AWSSDK.BedrockRuntime" Version="4.0.6" />
+    <PackageReference Include="AWSSDK.SimpleSystemsManagement" Version="4.0.5" />
     <PackageReference Include="AWSSDK.SQS" Version="4.0.1.2" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.8" />
 	<PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.8" />