interactive chat using Lex and ChatGPT
1.0.0
A Amazon Lex é um serviço completo de IA de gerenciamento que usa modelos de linguagem natural para projetar, construir, testar e distribuir interface interativa para aplicativos. Assim, o chatbot feito da Amazon Lex pode identificar as intenções para que você possa enviar e receber uma conversa contínua, para que você possa exibir as informações necessárias para cumprir suas intenções. Além disso, a Amazon Kendra pode ser usada para responder às intenções que não são identificadas na Amazon Lex. Da mesma forma, usando a API aberta de terceiros, você pode obter efeitos semelhantes. Em novembro de 2022, o ChatGPT foi lançado, mostrando excelente capacidade de conversa, possibilitando o uso do ChatGPT como API Open e Kendra. Nesta postagem, gostaria de explicar como implementar um chatbot interativo que usa o ChatGPT como uma API aberta para responder às intenções que não são definidas com antecedência.
A arquitetura que você implementa aqui é a seguinte. Usando o Amazon CloudFront, fornecemos uma página da web para bate -papo. A mensagem de bate -papo inserida pelo usuário usa a Amazon API Gateway e a AWS Lambda para responder à intenção do Lex. No entanto, se houver uma intenção que não seja reconhecida no LEX, a função Lambda será usada para consultar o ChatGPT e o resultado será exibido na janela de bate -papo. A infraestrutura para configurar esse chatbot interativa é criada e gerenciada usando a AWS CDK. Como toda a infraestrutura é composta por servidor (sem servidor), é possível operar de maneira estável o sistema através de escala automática, mesmo em tráfego eficiente e flutuante na superfície de manutenção.
Veja abaixo para uma operação detalhada.
Etapa 1: O usuário tenta se conectar à página da web do Chatbot com um domínio do CloudFront e carrega HTML, CSS e JavaScript armazenados no S3.
Etapa 2: insira uma mensagem de bate -papo na página da web. No momento, o recurso "/bate -papo" solicitará uma mensagem de texto no formato JSON no recurso "/bate -papo".
Etapa 3: O CloudFront envia uma solicitação para a API Gateway.
Etapa 4: o gateway da API chama a função Lambda conectada ao recurso /Chat.
Etapa 5: As funções Lambda passam a mensagem de bate -papo para Lex usando a API Lex V2.
Etapa 6: Lex executa o comportamento correspondente se houver uma intenção definida por intenção. Se você não conseguir reconhecer suas intenções, envie uma solicitação para entrar em contato com o ChatGPT.
Etapa 7: Se você responder no ChatGPT, a resposta será entregue à ordem inversa do estágio anterior e será entregue ao usuário.
A região de Seul não suporta o Lex V1, mas apenas o Lex V2 suporta. Portanto, o reconhecimento do Lex V2 é usado para enviar a entrada do usuário para a mensagem para a mensagem. O cliente V2 do Lex Runtime define o seguinte.
import { LexRuntimeV2Client , RecognizeTextCommand } from "@aws-sdk/client-lex-runtime-v2" ; A função Lambda é separada do evento e entrega a mensagem usando a botaliaside ou botida, como mostrado abaixo, e extrai e passa a mensagem da resposta entregue da LEX.
const text = event . text ;
let lexParams = {
botAliasId : process . env . botAliasId ,
botId : process . env . botId ,
localeId : process . env . localeId ,
text : text ,
sessionId : process . env . sessionId ,
};
const lexClient = new LexRuntimeV2Client ();
const command = new RecognizeTextCommand ( lexParams );
const data = await lexClient . send ( command );
return {
statusCode : 200 ,
msg : data [ 'messages' ][ 0 ]. content ,
};Em março de 2023, a API oficial do ChatGPT foi lançada. O caminho da nova API é "/v1/bate-papo/conclusões" e usa o modelo "GPT-3.5-Turbo". Este modelo pode ser usado a um custo 90% menor em comparação com o modelo existente "Text-Davinci-003", mas não pode ser feito para pesquisar o clima no ChatGPT. Aqui, descreveremos como usar o modelo "Text-Davinci-003" que suporta a pesquisa durante o bate-papo com a API oficial do ChatGPT.
A solicitação é feita pela API ChatGPT fornecida pelo OpenAI, "v1/bate -papo/conclusões" para postagem HTTPS. Para fazer isso, usamos busca aqui. No momento, o cabeçalho da solicitação a ser entregue ao ChatGPT deve incluir autorização e tipo de conteúdo, como mostrado abaixo. A chave da API necessária para a autorização é emitida pelo OpenAI: chave da API e armazenada como uma variável de ambiente. Ao solicitar uma mensagem, a função pode ser especificada como "usuário", "sistema" ou "assistente" de acordo com o Guia de transição da API ChatGPT. O código detalhado pode ser encontrado aqui (index.mjs).
import fetch from 'node-fetch' ;
const apiKey = process . env . OPENAI_API_KEY
let msg = "" ;
const res = await fetch ( 'https://api.openai.com/v1/chat/completions' ,{
method : "POST" ,
headers : {
"Authorization" : "Bearer " + apiKey ,
"Content-Type" : "application/json" ,
},
body : JSON . stringify ({
"model" : "gpt-3.5-turbo" ,
"messages" : [
{ "role" : "user" , "content" : prompt },
],
}),
});Quando você envia a mensagem de resposta enviada pelo ChatGPT, você deve enviá -lo para o formato abaixo ao enviá -lo para Lex. Nesse caso, o SessionState deve incluir dialogaction e intenção, e o nome da intenção deve ser extraído da entrada. Além disso, a mensagem de resposta do ChatGPT é colocada em "conteúdo" de "mensagens" e entregue da seguinte maneira.
if ( res . ok ) {
const data = await res . json ();
console . log ( "output: " , data . choices [ 0 ]);
msg = `[ ChatGPT ] $ { data . choices [ 0 ]. message . content }`;
console . log ( "msg: " + msg );
const intentName = event . interpretations [ 0 ]. intent . name ; // intent name
response = {
"sessionState" : {
"dialogAction" : {
"type" : "Close"
},
"intent" : {
"confirmationState" : "Confirmed" ,
"name" : intentName ,
"state" : "Fulfilled" ,
},
},
"messages" : [
{
"contentType" : "PlainText" ,
"content" : msg ,
}
]
}
} O modelo "text-davinci-003" usa "v1/conclusões" de acordo com a API de conclusão. Aqui você é implementado usando a biblioteca OpenAI Node.js. O código detalhado pode ser encontrado aqui (index-davinch.mjs).
import { Configuration , OpenAIApi } from " openai ";
const configuration = new Configuration({
apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);
const models = ['text-davinci-003','code-davinci-002'];
const frequency_penalty = 0.5;
const max_tokens = 2000;
const presence_penalty = 0.1;
const temperature = 0;
const top_p = 1;
const model_name = models[0];
const prompt = event.text;
const params = {
model: model_name,
prompt: prompt,
temperature: temperature,
max_tokens: max_tokens,
top_p: top_p,
frequency_penalty: frequency_penalty,
presence_penalty: presence_penalty,
};
const result = await openai.createCompletion(params);
const choices = result.data.choices;
return {
statusCode: 200,
id: result.data.id,
msg: choices[0].text,
}; O cliente transmite a mensagem de bate -papo, como mostrado abaixo, no servidor de bate -papo e o exibe na bolha de bate -papo receptor quando a resposta ocorre. O endereço do servidor de bate -papo aqui é o domínio do CloudFront. O código detalhado é confirmado aqui (chat.js).
function sendRequest ( text ) {
const uri = "/chat" ;
const xhr = new XMLHttpRequest ();
xhr . open ( "POST" , uri , true );
xhr . onreadystatechange = () => {
if ( xhr . readyState === 4 && xhr . status === 200 ) {
response = JSON . parse ( xhr . responseText );
console . log ( "response: " + JSON . stringify ( response ));
addReceivedMessage ( response . msg )
}
};
var requestObj = { "text" : text }
console . log ( "request: " + JSON . stringify ( requestObj ));
var blob = new Blob ([ JSON . stringify ( requestObj )], { type : 'application/json' });
xhr . send ( blob );
}Aqui você pode configurar o AWS CDK usando o TypeScript. O código detalhado pode ser encontrado aqui (CDK-chatbot-sack.ts).
A função Lambda para Lex é definida como abaixo. Deve incluir botaliasid e botaliasídeos no ambiente. Aqui, usamos chatbot em coreano, por isso especificamos "ko_kr" como localId, como mostrado abaixo. Esta função Lambda deve ter permissões para o gateway Lex e API.
// Lambda for lex
const lambdaLex = new lambda . Function ( this , 'lambda-function-lex' , {
description : 'lambda for chat' ,
functionName : 'lambda-function-lex' ,
handler : 'index.handler' ,
runtime : lambda . Runtime . NODEJS_18_X ,
code : lambda . Code . fromAsset ( path . join ( __dirname , '../../lambda-lex' )),
timeout : cdk . Duration . seconds ( 120 ),
environment : {
botId : "BSZQXD0ABN" ,
botAliasId : "TSTALIASID" ,
localeId : "ko_KR" , // en_US
sessionId : "mysession-01" ,
}
});
const lexPolicy = new iam . PolicyStatement ({
actions : [ 'lex:*' ],
resources : [ '*' ],
});
lambdaLex . role ?. attachInlinePolicy (
new iam . Policy ( this , 'rekognition-policy' , {
statements : [ lexPolicy ],
}),
);
// permission for api Gateway
lambdaLex . grantInvoke ( new iam . ServicePrincipal ( 'apigateway.amazonaws.com' )); A entrada do LEX está definida para receber através do método POST com o recurso "/bate -papo", como mostrado abaixo, usando o gateway da API.
const api = new apiGateway . RestApi ( this , 'api-chatbot' , {
description : 'API Gateway for chatbot' ,
endpointTypes : [ apiGateway . EndpointType . REGIONAL ],
deployOptions : {
stageName : stage ,
},
});
const chat = api . root . addResource ( 'chat' );
chat . addMethod ( 'POST' , new apiGateway . LambdaIntegration ( lambdaLex , {
passthroughBehavior : apiGateway . PassthroughBehavior . WHEN_NO_TEMPLATES ,
credentialsRole : role ,
integrationResponses : [{
statusCode : '200' ,
}],
proxy : false ,
}), {
methodResponses : [
{
statusCode : '200' ,
responseModels : {
'application/json' : apiGateway . Model . EMPTY_MODEL ,
},
}
]
}); Para ignorar os CORs, registre o comportamento do recurso "/bate -papo", como mostrado abaixo.
distribution . addBehavior ( "/chat" , new origins . RestApiOrigin ( api ), {
cachePolicy : cloudFront . CachePolicy . CACHING_DISABLED ,
allowedMethods : cloudFront . AllowedMethods . ALLOW_ALL ,
viewerProtocolPolicy : cloudFront . ViewerProtocolPolicy . REDIRECT_TO_HTTPS ,
});Envie o texto para o chatgpt e prepare a função Lambda que recebe a resposta. Onde o OpenAI_API_KEY é uma chave de API emitida pelo OpenAI.
const lambdachat = new lambda . Function ( this , 'lambda-chatgpt' , {
description : 'lambda for chatgpt' ,
functionName : 'lambda-chatgpt' ,
handler : 'index.handler' ,
runtime : lambda . Runtime . NODEJS_18_X ,
code : lambda . Code . fromAsset ( path . join ( __dirname , '../../lambda-chatgpt' )),
timeout : cdk . Duration . seconds ( 120 ),
environment : {
OPENAI_API_KEY : "123456" ,
}
}); Por conveniência, preparamos a distribuição usando o Cloud9 na região de Seul. O Cloud9 fornece um ambiente conveniente para criar, executar e depurar código no navegador. Digite o Cloud9 Console, selecione [Criar ambiente] e digite o nome como mostrado abaixo. Aqui, entrei no "chatbot". Posteriormente, o restante é mantido e selecione [Criar].
Quando o Cloud9 é criado, [aberto] e prepare o terminal como mostrado abaixo.
Faça o download da fonte como mostrado abaixo.
git clone https : //github.com/kyopark2014/interactive-chat-using-Lex-and-ChatGPTVá para a pasta CDK e instale as bibliotecas necessárias. A AWS-CDK-LIB é uma biblioteca CDK 2.0.
cd interactive - chat - using - Lex - and - ChatGPT / cdk - chatbot && npm installSe você estiver usando o CDK pela primeira vez, deve executar o bootstrap, como mostrado abaixo. Onde o ID da conta aqui significa número da conta de 12 dígitos. Você pode verificar na tela do console da AWS ou verificando o comando "AWS STS GET-CALLER-IDEDIDADE-QUERY-IDPUPT Text.
cdk bootstrap aws : //account-id/ap-northeast-2Crie o Bot Helloworld de acordo com o Hello World Bot na Workshop de construção do Amazon Lex Korean Chatbot. "Hello World Bot" é um bot simples que pede e verifica o nome.
Depois de concluir a criação de "Hello World Bot", acesse o console do bot e selecione "Helloworldbot". Você pode ver que o botid é "bszqxd0abn", como mostrado abaixo.
Se você selecionar [Aliases] de "HelloworldBot", poderá conhecer aliases como mostrado abaixo. Selecione "TestBotoalias" aqui.
Você pode ver que a botaliasida é "tstaliasid", como mostrado abaixo.
Retorne ao Cloud9 e abra "" interativo-chat-use-lex-to-chtgpt/cdk-lex/lib/lix-lex-sack.ts "no explorador de arquivo esquerdo e abra" lambda for lex " Atualize o botaliasid. Onde o SessionID mantém o valor atual ou inseriu qualquer valor.
Além disso, digite "OpenAI_API_KEY" no ambiente de "Lambda for ChatGPT". Se você não tiver uma chave pré -recebida, será emitido no OpenAI: API Key.
Agora crie uma infraestrutura completa com CDK.
cdk deployQuando é instalado normalmente, a seguinte "saída" é mostrada. Aqui, a distribuiçãoDomainName é "d3ndv6lhze8yc5.cloudfront.net" e weburl é "https://d3ndv6lhze8yc5.cloudfront.net/chat.html".
Selecione "HellowWorldBot" no AWS LEX Console e selecione [idiomas] em "Aliases" e selecione [coreano (Coréia do Sul)], como mostrado abaixo.
Selecione "Lambda-chatgpt" como [Soucet] e [versão da função lambda ou alias] Selecione "$ mais recente" e selecione [Salvar].
Em seguida, selecione [Fallbackintent] como mostrado abaixo em [intenções] de "hellowworldbot".
Role para baixo e selecione [Opções avançadas] do Fullfillment e Ativa [Use uma função Lambda para atendimento] do pop -up abaixo.
Selecione [Build] na parte superior da tela para aplicar o conteúdo alterado.
"Weburl" https://d3ndv6lhze8yc5.cloudfront.net/chat.html "está conectado à tela de bate -papo no navegador. Você pode conversar com Lex no navegador da web, como mostrado abaixo. A questão de "Lex", que é a questão após a operação de intenção, não foi registrada como uma intenção. Dependendo das configurações do navegador, talvez você não consiga receber parte da resposta ao ChatGPT.
Se você não usar mais a infraestrutura, poderá excluir todos os recursos, como mostrado abaixo.
cdk destroy Implementei chatbot interativo usando o Amazon Lex e o ChatGPT e expliquei como usar o AWS CDK para desenvolver e operar efetivamente a infraestrutura. Ao usar o ChatGPT, você também pode melhorar sua usabilidade, dando aos usuários a resposta apropriada às intenções que não são reconhecidas no LEX. O ChatGPT já provou sua excelente capacidade de conversa, e vários modelos de GPT estão sendo anunciados atualmente. Portanto, ao introduzir esses modelos de inteligência artificial em serviços de chatbot, como a LEX, espera -se que ele melhore a usabilidade do usuário e forneça um melhor serviço.
