alexa gpt
1.0.0
Boostez votre Alexa en la faisant répondre en tant que ChatGPT.
Ce référentiel contient un didacticiel sur la façon de créer une compétence Alexa simple qui utilise l'API OpenAI pour générer des réponses à partir du modèle ChatGPT.
Connectez-vous à votre compte de développeur Amazon et accédez à la console de développement Alexa.
Cliquez sur « Créer une compétence » et nommez la compétence « Chat ». Choisissez la langue principale en fonction de votre langue.
Choisissez "Autre" et "Personnalisé" pour le modèle.
Choisissez « hébergé par Alexa (Python) » pour les ressources backend.
Vous avez maintenant deux options :
Ou si vous souhaitez créer la compétence manuellement
Dans la section "Build", accédez à l'onglet "JSON Editor".
Si vous avez directement importé la compétence depuis ce référentiel, remplacez simplement « invocationName » par « chat » ou un autre mot préféré pour l'activation et passez à l'étape 12.
Toutefois, si vous choisissez de créer manuellement la compétence, remplacez le contenu JSON existant par le contenu JSON fourni :
{
"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" : []
}
}
}
Enregistrez le modèle et cliquez sur "Construire le modèle".
Accédez à la section "Code" et ajoutez "openai" au fichier conditions.txt. Votre fichier exigences.txt devrait ressembler à ceci :
ask-sdk-core==1.11.0
boto3==1.9.216
requests>=2.20.0Créez une clé API OpenAI sur la page Clés API en cliquant sur "+ Créer une nouvelle clé secrète".
Remplacez votre fichier lambda_functions.py par le lambda_function.py fourni.
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 ()Mettez votre clé API OpenAI que vous avez obtenue de votre compte OpenAI
Enregistrez et déployez. Allez dans la section « Test » et activez « Tests de compétences » dans « Développement ».
Vous êtes maintenant prêt à utiliser votre Alexa en mode ChatGPT. Vous devriez voir des résultats comme celui-ci :
Veuillez noter que l'exécution de cette compétence entraînera des coûts pour l'utilisation d'AWS Lambda et de l'API OpenAI. Assurez-vous de comprendre la structure tarifaire et de surveiller votre utilisation pour éviter des frais inattendus.
