Integrating Chat-GPT with Lambda
Its been while I was reading about ChatGPT and its usefulness over the tech blogs. I was curious on how to integrate ChatGPT with the application and expose API which can be consumed.
So I was looking to get started and with very little effort, I was able to create a small application using AWS lambda which integrates with the OpenAI.
In this blog, I will guide you with the step by step process I followed to create my sample application.
Tools I used are:
1. AWS SAM CLI
2. NPM package for Open API
Before we start, you need to create the API keys for the chatGPT from here.
You can refer to the above link installing SAM CLI. Once the CLI is installed, you can follow with me to create the application structure which we are going to deploy to AWS. You can refer here for the SAM CLI commands.
Create a project using sam init --name chatGPT-POC
and select from the option for creating project from Quick start template or any custom template. I will go with Quick Start Template.
From the template selection, I selected Serverless API template and runtime as nodejs16.x
You can enable the X-Ray
tracing and Cloudwatch Application Insights
if you want.
This will create a basic application structure with few of the sample lambda functions and a template.yml
file.
Before we add a new lambda handler for the chatGPT API, add the dependency in the package.json
for openAI.
npm install openai --save
Now your package.json
should look like this.
{
"name": "chatGPT-POC",
"description": "chatGPT-POC-description",
"version": "0.0.1",
"private": true,
"dependencies": {
"aws-sdk": "^2.799.0",
"openai": "^3.2.1"
},
"devDependencies": {
"jest": "^26.6.3"
},
"scripts": {
"test": "jest"
}
}
I have used AWS Secrets Manager to store the the API key as a best practice. Right now I am copying the secret value from the AWS console. You can also add that dynamically using a script.
Create a lambda definition in the template.yaml
as below. The function should have the permission to access the AWS Secrets Manager to get the secret.
GetChatGPTPromptFunction:
Type: AWS::Serverless::Function
Properties:
Handler: src/handlers/get-chat-gpt-prompt.lambdaHandler
Runtime: nodejs16.x
Architectures:
- x86_64
MemorySize: 128
Timeout: 300
Description: A function that returns the response from the chat prompt
Policies:
- Version: 2012-10-17
Statement:
- Action: secretsmanager:GetSecretValue
Effect: Allow
Resource: !Ref ChatGPTSecret
Environment:
Variables:
SECRET_NAME: !Ref ChatGPTSecret
Events:
Api:
Type: Api
Properties:
Path: /getPrompt
Method: POST
Add the lambda function in the src/hanlders folder. The lambda contains lambdaHandler
which is called from the API gateway and other helper functions such as getSecretFromSecretManager
, getOpenAIObject
, getChatGPTPrompt
.
The lambda function should look something similar to this
const AWS = require('aws-sdk');
const { Configuration, OpenAIApi } = require('openai');
AWS.config.update({region: 'us-east-1'});
exports.lambdaHandler = async (event) => {
try {
const input = JSON.parse(event.body);
const chatGPTSecret = await exports.get_secret_from_secretsmanager();
const openai = await exports.getOpenAIObject(chatGPTSecret);
const gptResponse = await exports.getChatGPTPrompt(openai, input);
console.log(gptResponse);
return {
statusCode: 200,
body: JSON.stringify(gptResponse)
}
} catch (error) {
console.log(error);
return {
statusCode: 500,
body: JSON.stringify(error)
}
}
}
exports.getSecretFromSecretsManager = async () => {
const secretsmanager = new AWS.SecretsManager();
const params = {
SecretId: process.env.SECRET_NAME
};
const data = await secretsmanager.getSecretValue(params).promise();
return data.SecretString;
}
exports.getOpenAIObject = async (apiKey) => {
const configuration = new Configuration({
apiKey
});
const openai = new OpenAIApi(configuration);
return openai;
}
exports.getChatGPTPrompt = async (openai, input) => {
const response = await openai.createCompletion({
model: 'text-davinci-003',
prompt: input.data,
temperature: 1,
max_tokens: 256,
top_p: 1
});
return response.data.choices[0].text;
}
Now you are done with your lambda function which connects to the chatGPT. You just need to build and deploy the application to the AWS.
Run sam build
command to build the application.
Last step in this process is to deploy this stack on AWS using SAM CLI.
Run sam deploy --guided
command and fill the answers in the prompt.
You can now access this API from the postman or any other similar tool.
Our sample application is working well 😍.
Our application still has much room for the improvements like:
- Adding secrets value from the script on runtime
- Writing test cases
- Adding OpenAPI spec and validations
- Adding parameters in the API call
You can find the entire application in my github repository.
Feel free to share your feedback on my blog that will be my fuel for the upcoming blog 😎.