Créer un agent de café avec Amazon Bedrock et Shopify

Aujourd'hui, je vais vous expliquer comment travailler avec Bedrock de manière sûre et fiable et, en même temps, en apprendre un peu plus sur le café.

Vous apprendrez à utiliser l'API Amazon Bedrock de modèles texte et multimodaux à l'aide de Python pour générer des noms, un logo et un menu pour votre café et à créer un agent qui se connecte à une API Shopify pour prendre les commandes.

Shopify est (à mon avis) la meilleure plateforme de commerce électronique qui existe.

Et tout comme AWS, Shopify dispose d'une API pour tout et d'une plateforme pour les développeurs

Enfin vous créerez un frontend en utilisant Streamlit pour offrir une expérience utilisateur unique et donner vie à votre agent.

? Indice

• Invocation de l'API Bedrock
• Création d'un agent Amazon Bedrock qui interagit avec Shopify

? Appel de l'API Amazon Bedrock pour générer des noms, un logo et un menu pour votre café

Le moment d'ouvrir une cafétéria ou d'avoir des idées créatives pour toute entreprise est une excellente opportunité de s'appuyer sur l'IA générative (GenAI) et d'en tirer le meilleur parti.

Grâce à Amazon Bedrock, vous pouvez l'utiliser, mais... Comment ce service est-il consommé ?

Chaque service dans AWS possède une API, et Amazon Bedrock ne fait pas exception. Ci-dessous, j'explique comment utiliser l'API Amazon Bedrock à travers un exemple pour générer des noms et un menu pour une cafétéria en déplacement.

Et je vous montre aussi comment consommer un modèle multimodal capable d'analyser des images.

Instructions pour programmer un script Python à exécuter localement ou dans une fonction Lambda pour appeler Amazon Bedrock :

Vous devez d'abord activer l'accès aux modèles dans les instructions Bedrock ici

Exigences :

• Un compte sur AWS, si vous n'avez pas de compte, vous pouvez en ouvrir un ici
• Instructions AWS CLI ici
• Python 3.11 ou supérieur

Étape 1) Créez un environnement Python virtuel Instructions ici

Dans le dossier bedrock_examples de ce référentiel, vous trouverez différents exemples utilisés ci-dessous pour invoquer le modèle fondateur.

Dans le dossier des invites, vous trouverez les exemples d'invites, que vous pourrez utiliser pour générer le nom, le menu et une invite à transmettre à un modèle de génération d'image que vous pourrez appeler à la fois dans le terrain de jeu Amazon Bedrock et par invoquer l'API depuis Python.

Étape 2) Installer la configuration requise

pip install -r requirements.txt

Étape 3) Configurer Boto3 Plus d'informations sur boto3

Ici, je configure le client AWS en lui disant d'utiliser le profil genaiday installé sur mon ordinateur et j'appelle le client bedrock-runtime qui me permettra d'invoquer le modèle fondateur.

#Cambiar la region y el perfil de AWS
aws = boto3.session.Session(profile_name='genaiday', region_name=region)
client = aws.client('bedrock-runtime')

Étape 4) Exemple : Invoquer un modèle de texte

Cette fonction appelle la méthode invoke_model et je passe l'invite indiquée par l'utilisateur et renvoie la réponse

La partie la plus importante, ce sont les messages envoyés :

pip install -r requirements.txt

#Cambiar la region y el perfil de AWS
aws = boto3.session.Session(profile_name='genaiday', region_name=region)
client = aws.client('bedrock-runtime')

Exemple :

{
                "role": "user",
                "content": [{
                    "type": "text",
                    "text": prompt
                }]
            }

Étape 5) Exemple : Invoquez un modèle multimodal.

Ici, le processus est similaire, seulement vous devez ajouter le type MIME du fichier envoyé, pour cela il existe une fonction qui obtient le type MIME
en fonction du nom du fichier

def call_text(prompt,modelId="anthropic.claude-3-haiku-20240307-v1:0"):
    #esta función es para llamar un modelo de texto
    config = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 4096,
        "messages": [
            {
                "role": "user",
                "content": [{
                    "type": "text",
                    "text": prompt
                }]
            }
        ]
    }

    body = json.dumps(config)
    modelId = modelId
    accept = "application/json"
    contentType = "application/json"

    response = client.invoke_model(
        body=body, modelId=modelId, accept=accept, contentType=contentType)
    response_body = json.loads(response.get("body").read())
    results = response_body.get("content")[0].get("text")
    return results

Ensuite pour invoquer le modèle, les messages doivent être les suivants :

print("Haiku")
print(call_text("Estoy buscando armar un local de café al paso, dame 5 nombres para un local.")

L'invocation du modèle ressemble à ceci :

def read_mime_type(file_path):
    # Este hack es para versiones de python anteriores a 3.13
    # Esta función lee el mime type de un archivo
    mimetypes.add_type('image/webp', '.webp')
    mime_type = mimetypes.guess_type(file_path)
    return mime_type[0]

Exemple :

 "messages": [
        {
            "role": "user",
            "content": [
                {
                     "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": read_mime_type(file),
                            "data": base64.b64encode(open(file, "rb").read()).decode("utf-8")
                        }
                },
                {
                    "type": "text",
                    "text": caption
            }]
        }
    ]

? Création d'un agent Amazon Bedrock qui interagit avec Shopify

Pour créer un agent Amazon Bedrock :

Assurez-vous d'avoir les modèles Bedrock que vous souhaitez utiliser avec l'accès activé. Instructions ici, dans ce cas nous utiliserons Claude 3 Haiku et Sonnet

Créez ensuite l'agent Bedrock dans la console AWS :

1) Accédez au service Bedrock
2) Agents
3) Créer un agent

4) Donner un nom à l'agent, dans notre cas "Pause-Coffee-Agent
5) La description est facultative.
6) L'une des étapes les plus importantes consiste à choisir le modèle de base qui permettra à notre agent de fonctionner correctement. Si vous souhaitez savoir comment choisir le meilleur modèle adapté à votre cas d'utilisation, voici un guide sur le modèle Amazon Bedrock. Évaluation .
7) La prochaine étape est l'invite qui guidera votre modèle, ici vous devez être le plus précis possible et faire ressortir vos compétences d'ingénieur prompt, si vous ne savez pas par où commencer, je vous recommande de visiter ce guide où vous vous trouverez les meilleures lignes directrices pour le modèle que vous utilisez, et une autre ressource très utile est la console anthropique.

C'est l'invite que j'ai utilisée pour l'exemple d'agent, je recommande d'écrire l'invite en anglais car les modèles ont été formés en anglais et parfois écrire dans la langue source de la formation permet d'éviter des comportements erronés.

def call_multimodal(file,caption,modelId="anthropic.claude-3-haiku-20240307-v1:0"):
    #esta funcion es para llamar a un modelo multimodal con una imagen y un texto
    config = {
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 4096,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                     "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": read_mime_type(file),
                            "data": base64.b64encode(open(file, "rb").read()).decode("utf-8")
                        }
                },
                {
                    "type": "text",
                    "text": caption
            }]
        }
    ]
    }

    body = json.dumps(config)
    modelId = modelId
    accept = "application/json"
    contentType = "application/json"

    response = client.invoke_model(
    body=body, modelId=modelId, accept=accept, contentType=contentType)
    response_body = json.loads(response.get("body").read())
    results = response_body.get("content")[0].get("text")
    return results

8) Configuration supplémentaire, vous devez permettre à l'agent de capturer les entrées de l'utilisateur, étant donné qu'il manquera sûrement d'informations pour traiter la commande, par exemple : Il devra demander les produits que le client souhaite, le nom , entre autres.

9) Groupes d'actions : Un groupe d'actions définit les actions dans lesquelles l'agent peut aider l'utilisateur. Par exemple, vous pouvez définir un groupe d'actions indiquant TakeOrder qui peut avoir les actions suivantes

• Liste des produits
• Traiter la commande

Pour créer un groupe d'actions dont vous aurez besoin pour chaque action :

• Le nom
• Les paramètres

Les groupes d'actions à exécuter invoquent généralement une fonction Lambda, depuis Bedrock vous pouvez :

• Créez une fonction lambda depuis la console Bedrock (Sélectionnez Création rapide d'une fonction lambda)

• Choisissez une fonction lambda déjà créée ici les instructions sur ce à quoi ressemble l'événement et la réponse attendue pour chaque groupe d'action

Si vous choisissez de créer la fonction lambda depuis la console Bedrock, une fonction sera créée en python avec un code source de base que vous devrez ensuite modifier, dans ce repo dans le fichier agents/action_group/lambda.py vous avoir l'exemple de code modifié pour le faire fonctionner avec l'agent.

Voici les variables qui vous donneront les informations nécessaires :

• fonction : est le nom de l'action invoquée, dans le cas de l'exemple cela peut être : get_products (pour lister les produits), et place_order (pour générer la commande dans Shopify)
• paramètres : est un dictionnaire de paramètres.

Dans l'exemple suivant, vous pouvez voir qu'il y a deux actions :

• get_products qui ne nécessite aucun paramètre
• place_order qui a 3 paramètres :

Parametro	Descripcion	Tipo	Obligatorio
customerEmail	Email of the customer	string	False
customerName	Name of the customer	string	True
products	SKUs and quantities to add to the cart in the format [{ variantId: variantId, quantity: QUANTITY }]	array	True

Ainsi, par exemple, lorsque vous appelez la fonction get_products dans la fonction lambda, elle est gérée comme ceci :

Il existe une fonction get_products définie qui sera chargée d'interroger l'API Shopify (À des fins éducatives, nous renvoyons tous les produits)

Si vous souhaitez que cela fonctionne dans Shopify vous devez remplacer les variables suivantes par celles de votre boutique :

pip install -r requirements.txt

#Cambiar la region y el perfil de AWS
aws = boto3.session.Session(profile_name='genaiday', region_name=region)
client = aws.client('bedrock-runtime')

Ensuite, dans le gestionnaire de la fonction lambda, le nom de la fonction appelée est vérifié et la réponse est renvoyée dans le format dont action_group a besoin :

{
                "role": "user",
                "content": [{
                    "type": "text",
                    "text": prompt
                }]
            }

Les extraits de code ci-dessus font partie de la fonction lambda trouvée ici

10) Appuyez sur Enregistrer et Quitter, et c'est tout ! L'agent est prêt à être testé.

L'Agent en action

La prochaine chose est de tester l'agent et de valider qu'il fonctionne, depuis Bedrock vous pouvez tester l'agent, et si pendant la conversation vous cliquez sur "Voir la trace ou Afficher la trace", il vous montrera le processus de raisonnement, c'est ici vous devez accorder une attention particulière et effectuer les ajustements que vous jugez nécessaires dans l'invite ou rechercher un autre modèle si vous constatez que celui que vous avez choisi ne fonctionne pas comme prévu.

Une fois que vous êtes satisfait de l'agent, vous pouvez créer un alias, un alias est un identifiant à travers lequel vous pourrez appeler l'agent depuis l'API Amazon Bedrock, lorsque vous créerez l'alias, il créera une version de l'agent automatiquement, ou vous pouvez pointer vers une version déjà existante, avoir différents alias et différentes versions vous aidera à contrôler le processus de déploiement de l'agent, par exemple :

• Vous pouvez avoir un alias "développement" qui ira aux derniers tests Agent
• Un alias "preprod" qui serait l'agent en mode pré-production
• Un alias "prod" et voici l'agent live.

Ensuite il ne reste plus qu'à noter l'alias de production correspondant à la version que vous souhaitez faire vivre.

Comment invoquer l'agent

Pour cela, dans le dossier agents/frontend j'ai laissé un fichier appelé agent.py.

Ce développement utilise Streamlit, un framework puissant pour créer des exemples d'applications d'apprentissage automatique

La partie du code qui invoque l'agent est la suivante :

def call_text(prompt,modelId="anthropic.claude-3-haiku-20240307-v1:0"):
    #esta función es para llamar un modelo de texto
    config = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 4096,
        "messages": [
            {
                "role": "user",
                "content": [{
                    "type": "text",
                    "text": prompt
                }]
            }
        ]
    }

    body = json.dumps(config)
    modelId = modelId
    accept = "application/json"
    contentType = "application/json"

    response = client.invoke_model(
        body=body, modelId=modelId, accept=accept, contentType=contentType)
    response_body = json.loads(response.get("body").read())
    results = response_body.get("content")[0].get("text")
    return results

Nous utilisons boto3 pour consommer l'API AWS, nous appelons le client bedrock-agent-runtime pour pouvoir invoquer l'agent.

Les paramètres que nous devons lui transmettre sont :

• IDagent
• agentAliasId
• inputText (l'invite)
• sessionId (la session, pour identifier les conversations)

Dans cet exemple, je définis les variables ici :

print("Haiku")
print(call_text("Estoy buscando armar un local de café al paso, dame 5 nombres para un local.")

Facilité:

Vous devez d'abord activer l'accès aux modèles dans les instructions Bedrock ici

Exigences :

• Instructions AWS CLI ici
• Python 3.11 ou supérieur

Je recommande de créer un environnement Python virtuel. Instructions ici

pip install -r requirements.txt

Exécution

#Cambiar la region y el perfil de AWS
aws = boto3.session.Session(profile_name='genaiday', region_name=region)
client = aws.client('bedrock-runtime')

Cela commencera à s'exécuter sur le port 8501 et vous pourrez visiter l'URL suivante : http://localhost:8501/ pour voir le frontend qui invoquera l'agent

Conclusion

Si vous avez suivi toutes les étapes que vous avez :

• Consommation de l'API Amazon Bedrock depuis Bedrock Playground et depuis Python
• Vous avez invoqué des textes fondateurs et des modèles multimodaux
• Vous avez créé un agent de toutes pièces qui consomme une API Shopify

Quelques liens pour suivre votre chemin au sein de GenerativeAI

Atelier AWS IA générative
Bases de connaissances sur le substrat rocheux
Anthropic Console (Pour déboguer nos invites)
Community.aws (plus d'articles générés par et pour la communauté)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!