alexa gpt
1.0.0
Aumente o seu Alexa fazendo-o responder como ChatGPT.
Este repositório contém um tutorial sobre como criar uma habilidade Alexa simples que usa a API OpenAI para gerar respostas a partir do modelo ChatGPT.
Faça login em sua conta de desenvolvedor Amazon e navegue até o Alexa Developer Console.
Clique em “Criar Habilidade” e nomeie a habilidade “Bate-papo”. Escolha a localidade principal de acordo com seu idioma.
Escolha “Outro” e “Personalizado” para o modelo.
Escolha "Hospedado por Alexa (Python)" para os recursos de back-end.
Agora você tem duas opções:
Ou se você quiser criar a habilidade manualmente
Na seção "Construir", navegue até a guia "Editor JSON".
Se você importou diretamente a habilidade deste repositório, basta alterar o "invocationName" para "chat" ou outra palavra preferida para ativação e prosseguir para o passo 12.
No entanto, se você optar por criar a habilidade manualmente, substitua o conteúdo JSON existente pelo conteúdo JSON fornecido:
{
"interactionModel" : {
"languageModel" : {
"invocationName" : " chat " ,
"intents" : [
{
"name" : " GptQueryIntent " ,
"slots" : [
{
"name" : " query " ,
"type" : " AMAZON.Person "
}
],
"samples" : [
" {query} "
]
},
{
"name" : " AMAZON.CancelIntent " ,
"samples" : []
},
{
"name" : " AMAZON.HelpIntent " ,
"samples" : []
},
{
"name" : " AMAZON.StopIntent " ,
"samples" : []
},
{
"name" : " AMAZON.NavigateHomeIntent " ,
"samples" : []
}
],
"types" : []
}
}
}
Salve o modelo e clique em “Construir Modelo”.
Vá para a seção "Código" e adicione "openai" ao require.txt. Seu requisitos.txt deve ficar assim:
ask-sdk-core==1.11.0
boto3==1.9.216
requests>=2.20.0Crie uma chave de API OpenAI na página de chaves de API clicando em "+ Criar nova chave secreta".
Substitua seu arquivo lambda_functions.py pelo lambda_function.py fornecido.
from ask_sdk_core . dispatch_components import AbstractExceptionHandler
from ask_sdk_core . dispatch_components import AbstractRequestHandler
from ask_sdk_core . skill_builder import SkillBuilder
from ask_sdk_core . handler_input import HandlerInput
from ask_sdk_model import Response
import ask_sdk_core . utils as ask_utils
import requests
import logging
import json
# Set your OpenAI API key
api_key = "YOUR_API_KEY"
logger = logging . getLogger ( __name__ )
logger . setLevel ( logging . INFO )
class LaunchRequestHandler ( AbstractRequestHandler ):
"""Handler for Skill Launch."""
def can_handle ( self , handler_input ):
# type: (HandlerInput) -> bool
return ask_utils . is_request_type ( "LaunchRequest" )( handler_input )
def handle ( self , handler_input ):
# type: (HandlerInput) -> Response
speak_output = "Chat G.P.T. mode activated"
session_attr = handler_input . attributes_manager . session_attributes
session_attr [ "chat_history" ] = []
return (
handler_input . response_builder
. speak ( speak_output )
. ask ( speak_output )
. response
)
class GptQueryIntentHandler ( AbstractRequestHandler ):
"""Handler for Gpt Query Intent."""
def can_handle ( self , handler_input ):
# type: (HandlerInput) -> bool
return ask_utils . is_intent_name ( "GptQueryIntent" )( handler_input )
def handle ( self , handler_input ):
# type: (HandlerInput) -> Response
query = handler_input . request_envelope . request . intent . slots [ "query" ]. value
session_attr = handler_input . attributes_manager . session_attributes
if "chat_history" not in session_attr :
session_attr [ "chat_history" ] = []
response = generate_gpt_response ( session_attr [ "chat_history" ], query )
session_attr [ "chat_history" ]. append (( query , response ))
return (
handler_input . response_builder
. speak ( response )
. ask ( "Any other questions?" )
. response
)
class CatchAllExceptionHandler ( AbstractExceptionHandler ):
"""Generic error handling to capture any syntax or routing errors."""
def can_handle ( self , handler_input , exception ):
# type: (HandlerInput, Exception) -> bool
return True
def handle ( self , handler_input , exception ):
# type: (HandlerInput, Exception) -> Response
logger . error ( exception , exc_info = True )
speak_output = "Sorry, I had trouble doing what you asked. Please try again."
return (
handler_input . response_builder
. speak ( speak_output )
. ask ( speak_output )
. response
)
class CancelOrStopIntentHandler ( AbstractRequestHandler ):
"""Single handler for Cancel and Stop Intent."""
def can_handle ( self , handler_input ):
# type: (HandlerInput) -> bool
return ( ask_utils . is_intent_name ( "AMAZON.CancelIntent" )( handler_input ) or
ask_utils . is_intent_name ( "AMAZON.StopIntent" )( handler_input ))
def handle ( self , handler_input ):
# type: (HandlerInput) -> Response
speak_output = "Leaving Chat G.P.T. mode"
return (
handler_input . response_builder
. speak ( speak_output )
. response
)
def generate_gpt_response ( chat_history , new_question ):
"""Generates a GPT response to a new question"""
headers = {
"Authorization" : f"Bearer { api_key } " ,
"Content-Type" : "application/json"
}
url = "https://api.openai.com/v1/chat/completions"
messages = [{ "role" : "system" , "content" : "You are a helpful assistant. Answer in 50 words or less." }]
for question , answer in chat_history [ - 10 :]:
messages . append ({ "role" : "user" , "content" : question })
messages . append ({ "role" : "assistant" , "content" : answer })
messages . append ({ "role" : "user" , "content" : new_question })
data = {
"model" : "gpt-4o-mini" ,
"messages" : messages ,
"max_tokens" : 300 ,
"temperature" : 0.5
}
try :
response = requests . post ( url , headers = headers , data = json . dumps ( data ))
response_data = response . json ()
if response . ok :
return response_data [ 'choices' ][ 0 ][ 'message' ][ 'content' ]
else :
return f"Error { response . status_code } : { response_data [ 'error' ][ 'message' ] } "
except Exception as e :
return f"Error generating response: { str ( e ) } "
sb = SkillBuilder ()
sb . add_request_handler ( LaunchRequestHandler ())
sb . add_request_handler ( GptQueryIntentHandler ())
sb . add_request_handler ( CancelOrStopIntentHandler ())
sb . add_exception_handler ( CatchAllExceptionHandler ())
lambda_handler = sb . lambda_handler ()Coloque sua chave de API OpenAI que você obteve de sua conta OpenAI
Salve e implante. Vá para a seção "Teste" e habilite "Teste de habilidade" em "Desenvolvimento".
Agora você está pronto para usar seu Alexa no modo ChatGPT. Você deverá ver resultados como este:
Observe que a execução desta habilidade incorrerá em custos de uso do AWS Lambda e da API OpenAI. Certifique-se de compreender a estrutura de preços e monitorar seu uso para evitar cobranças inesperadas.
