Creating-Blog-Content-with-Serverless-Generative-AI-Using-AWS-Bedrock

Generative AI has revolutionized various industries, offering innovative solutions that were previously unimaginable. Recently, I undertook an exciting project to create a serverless Generative AI product using AWS. This project leverages AWS Bedrock, API Gateway, S3, and Lambda to generate blog content from user queries.

The project aims to develop a serverless Generative AI that generates blog content based on user queries. The architecture consists of:

• API Gateway: Manages API requests.
• Lambda: Handles backend logic.
• AWS Bedrock: Provides foundational models for content generation.
• S3: Stores the generated content.

This is a step by step guide on how you can use AWS Bedrock to create AI applications on cloud.

Setup Instructions

AWS Bedrock Configuration

AWS Bedrock provides access to foundational AI models

1. Configure Bedrock:
   • Explore available models in AWS Bedrock.
   • Ensure correct permissions and model access for the Lambda function.
   • In the project, I have used LLaMa 2 Chat 13B

API Creation

Lambda Function

1. Create Lambda Function:

   • Navigate to the AWS Lambda console.
   • Create a new Lambda function.
   • Set up environment variables and permissions for accessing Bedrock and S3.

2. Lambda Function Code:

   • Create a virtual environment and install necessary libraries:

     python3 -m venv venv
     source venv/bin/activate
     pip install boto3

   • Compress and save the boto3 file in a folder, then compress it. Create a custom layer in the Lambda function and add the zip file to it.

   • Write Python code to handle the API request, generate content using Bedrock, and save to S3.Refer to app.py file in the repoistory.

      import boto3
      import botocore.config
      import json
      
      from datetime import datetime
      
      def blog_generate_using_bedrock(blogtopic:str)-> str:
          prompt=f"""<s>[INST]Human: Write a 200 words blog on the topic {blogtopic}
          Assistant:[/INST]
          """
      
          body={
              "prompt":prompt,
              "max_gen_len":512,
              "temperature":0.5,
              "top_p":0.9
          }
      
          try:
              bedrock=boto3.client("bedrock-runtime",region_name="us-west-1",
                                   config=botocore.config.Config(read_timeout=300,retries={'max_attempts':3}))
              response=bedrock.invoke_model(body=json.dumps(body),modelId="meta.llama2-13b-chat-v1")
      
              response_content=response.get('body').read()
              response_data=json.loads(response_content)
              print(response_data)
              blog_details=response_data['generation']
              return blog_details
          except Exception as e:
              print(f"Error generating the blog:{e}")
              return ""
      
      def save_blog_details_s3(s3_key,s3_bucket,generate_blog):
          s3=boto3.client('s3')
      
          try:
              s3.put_object(Bucket = s3_bucket, Key = s3_key, Body =generate_blog )
              print("Code saved to s3")
      
          except Exception as e:
              print("Error when saving the code to s3")
      
      
      
      def lambda_handler(event, context):
          # TODO implement
          event=json.loads(event['body'])
          blogtopic=event['blog_topic']
      
          generate_blog=blog_generate_using_bedrock(blogtopic=blogtopic)
      
          if generate_blog:
              current_time=datetime.now().strftime('%H%M%S')
              s3_key=f"blog-output/{current_time}.txt"
              s3_bucket='aws-bedrock-bloggen-pranjal'
              save_blog_details_s3(s3_key,s3_bucket,generate_blog)
      
      
          else:
              print("No blog was generated")
      
          return{
              'statusCode':200,
              'body':json.dumps('Blog Generation is completed')
          }

     • Change the S3 bucket name, region and foundational model using for application

3. Create API Gateway:

   • Go to the Amazon API Gateway console.
   • Create a new API.
   • Define endpoints and methods (e.g., POST for content generation).
   • Create a dev stage

2. Postman Setup:
   • Use Postman to send HTTP requests to the API and test its functionality.

S3 for Storage

Create an S3 bucket to store the generated blog content:

1. Create S3 Bucket:
   • Go to the S3 console.
   • Create a new bucket with appropriate permissions.
   • Configure the Lambda function to save the generated content in this bucket.
   • In the lambda code, change the bucket name with what you have used

Testing and Debugging

1. API Testing:

   • Use Postman to send requests

   • Ensure there are no extra space in the API and the API triggers the Lambda function correctly

     

2. Monitoring:

   • Use AWS CloudWatch to monitor logs and debug any issues with the Lambda function.

   • In the Cloudwatch you can see you the steps being follwed from API to output text file being saved in the S3 bucket.

     

Key Features

• Serverless Architecture: Utilizes AWS serverless services for scalability and cost efficiency.
• Generative AI: Employs advanced AI models in AWS Bedrock for high-quality content generation.
• Seamless Integration: Demonstrates the integration of multiple AWS services for automated content generation.
• Extensibility: The solution can be extended to various applications like document generation, Q&A systems, etc.

Conclusion

This project showcases a comprehensive guide to building a serverless Generative AI solution on AWS. By following the step-by-step instructions, you can replicate this process for similar use cases, leveraging AWS’s robust infrastructure to develop scalable and efficient AI-driven applications.

Contributing

Contributions are welcome! Please fork this repository and submit a pull request for any enhancements or bug fixes.

Video Result

GEN.AI.AWS.BEDROCK.1.mp4