Merge pull request #2742 from Sliiiin/main

Pattern update - apigw-lambda-bedrock-sam

Author: bfreiberg

apigw-lambda-bedrock-sam/README.md

@@ -1,6 +1,6 @@
 # Amazon API Gateway to AWS Lambda to Amazon Bedrock using SAM
 
-This sample project deploys an Amazon API Gateway REST API with an AWS Lambda integration. The Lambda function is written in Python, calls the Amazon Bedrock API for Anthropic Claude-v2 model and returns a response containing the generated content.
+This sample project deploys an Amazon API Gateway REST API with an AWS Lambda integration. The Lambda function is written in Python, calls the Amazon Bedrock API for Anthropic Claude 3.5 Sonnet model and returns a response containing the generated content.
 
 Learn more about this pattern at Serverless Land Patterns: serverlessland.com/patterns/apigw-lambda-bedrock
 
@@ -43,73 +43,18 @@ Amazon Bedrock users need to request access to models before they are available
 
    For production applications, you should [enable authentication for the API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-to-api.html) using one of several available options and [follow the API Gateway security best practices](https://docs.aws.amazon.com/apigateway/latest/developerguide/security-best-practices.html).
 
-5. Note the outputs from the SAM deployment process. These contain the resource names and/or ARNs which are used for next step as well as testing.
-6. Run the `create_lambda_layer.sh`. You may have to change the file permission to make it executable.  This will create the lambda layer with necessary boto3 api for bedrock.
-   ```bash
-   ./create_lambda_layer.sh
-   ```
-7. Provide a name for the Lambda layer. Such as: 
-   ```bash
-   Enter the name of the Layer: boto3-lambda-layer
-   ```
-   It will show output like below:
-   ```bash
-   Publishing the layer. Please wait ...
-   {
-    "Content": {
-      .....
-      .....
-    },
-    "LayerArn": "arn:aws:lambda:us-east-1:xxxxxxxxxxxx:layer:boto3-lambda-layer",
-    "LayerVersionArn": "arn:aws:lambda:us-east-1:xxxxxxxxxxxx:layer:boto3-lambda-layer:1",
-    "Description": "",
-    "CreatedDate": "YYYY-MM-DDT10:47:36.983+0000",
-    "Version": 1
-   }
-   ``` 
-8. You may have to press `q` to come out of the output. Copy the value of `LayerVersionArn` from the above output and provide it into the next step. Such as:
-   ```bash
-   Enter the LayerVersionArn from the above command: arn:aws:lambda:us-east-1:xxxxxxxxxxxx:layer:boto3-lambda-layer:1
-   ```
-9. Please copy the value of `ContentGenerationLambdaFunction` from the `sam deploy --guided` output and provide that as response to next question. Such as:
-   ```bash
-   Enter the Lambda function name from the SAM deploy output: your-stack-name-ContentGenerationLambdaXx-xxxxxxxxxxxx
-   ```
-   The script will now run aws cli command to add the newly created layer to the Lambda function. It will show output as below:
-   It will show output like below:
-   ```bash
-   Adding the new layer to your Lambda function's configuration. Please wait ...
-   {
-      "FunctionName": "your-stack-name-ContentGenerationLambdaXx-xxxxxxxxxxxx",
-      ......
-      ......
-      "State": "Active",
-      "LastUpdateStatus": "InProgress",
-      "LastUpdateStatusReason": "The function is being created.",
-      "LastUpdateStatusReasonCode": "Creating",
-      "PackageType": "Zip",
-      "Architectures": [
-         "arm64"
-      ],
-      "EphemeralStorage": {
-         "Size": 512
-      }
-   }      
-   ```    
-10. You may have to press `q` to come out of the output. The setup is ready for testing.
-
 ## How it works
 
-This SAM project uses Amazon Bedrock API for Anthropic Claude-v2 model to generate content based on given prompt. This is exposed through a serverless REST API. Please refer to the architecture diagram below:
+This SAM project uses Amazon Bedrock API for Anthropic Claude 3.5 Sonnet model to generate content based on given prompt. This is exposed through a serverless REST API. Please refer to the architecture diagram below:
 ![End to End Architecture](images/architecture.png)
 
 Here's a breakdown of the steps:
 
 1. **Amazon API Gateway**: Receives the HTTP POST request containing the prompt.
 
-2. **AWS Lambda**: Triggered by the API Gateway, this function forwards the prompt to Amazon Bedrock API using boto3 bedrock-runtime API. It uses Anthropic Claude-v2 model and sets other required parameters to fixed values for simplicity.
+2. **AWS Lambda**: Triggered by the API Gateway, this function forwards the prompt to Amazon Bedrock API using boto3 bedrock-runtime API. It uses Anthropic Claude 3.5 Sonnet model and sets parameters like temperature, max tokens, and other configuration options.
 
-3. **Amazon Bedrock**: Based on the given prompt, using Anthropic Claude-v2 model generates the content and returns the response to Lambda.
+3. **Amazon Bedrock**: Based on the given prompt, using Anthropic Claude 3.5 Sonnet model generates the content and returns the response to Lambda.
 
 4. **Response**: Lambda processes the Bedrock output and sends it back to the user via the API Gateway.
 
@@ -135,10 +80,6 @@ The API returns a response with generated content. Such as (Your out may vary):
 ```bash
 sam delete
 ```
-2. Delete the Lambda layer version using the `delete_lambda_layer.sh` script. You may have to give execution permission to the file. You will need to pass the Lambda layer name and the version in the inpout when requested:
-```bash
-./delete_lambda_layer.sh
-```
 
 ---
 

apigw-lambda-bedrock-sam/boto3-bedrock-layer.zip

@@ -13,32 +13,46 @@ def lambda_handler(event, context):
     prompt = body["prompt"]
     print("Prompt = " + prompt)
 
-    # Create the body
-    body = json.dumps({
-        'prompt': "\n\nHuman:" + prompt + "\n\nAssistant:",
+    # Create the request body using the messaging API format for Claude 3.5
+    request_body = json.dumps({
+        "anthropic_version": "bedrock-2023-05-31",
+        "max_tokens": 200,
+        "messages": [
+            {
+                "role": "user",
+                "content": prompt
+            }
+        ],
         "temperature": 0.5,
         "top_p": 1,
-        "top_k": 250,
-        "max_tokens_to_sample": 200,
-        "stop_sequences": ["\n\nHuman:"]
+        "top_k": 250
     })
 
     # Set the model id and other parameters required to invoke the model
-    model_id = 'anthropic.claude-v2'
+    model_id = 'anthropic.claude-3-5-sonnet-20240620-v1:0'
     accept = 'application/json'
     content_type = 'application/json'
 
     # Invoke Bedrock API
-    response = bedrock.invoke_model(body=body, modelId=model_id, accept=accept, contentType=content_type)
-    print(response)
-
+    response = bedrock.invoke_model(body=request_body, modelId=model_id, accept=accept, contentType=content_type)
+    
     # Parse the response body
     response_body = json.loads(response.get('body').read())
     print(response_body)
+    
+    # Extract the completion from the messaging API response format
+    completion = response_body.get('content', [{}])[0].get('text', '')
+    stop_reason = response_body.get('stop_reason', '')
+    
+    # Format the response to maintain backward compatibility with the existing API
+    formatted_response = {
+        'completion': completion,
+        'stop_reason': stop_reason
+    }
 
     return {
         'statusCode': 200,
         'body': json.dumps({
-            'generated-text': response_body
+            'generated-text': formatted_response
         })
     }