Appeler les modèles Anthropic Claude

Ce document explique comment appeler les modèles Claude d'Anthropic pour générer une réponse pour les entrées textuelles et multimodales à l'aide du SDK Vertex AI pour ABAP. Les modèles Claude peuvent accepter plusieurs modes d'entrée, y compris du texte, des images et des documents. Vous pouvez utiliser les modèles Claude pour des cas d'utilisation tels que les suivants :

• Résumer du texte au format libre
• Décrire ou interpréter des assets multimédias
• Traduire d'une langue à une autre

L'utilisation de modèles génératifs pour créer des fonctionnalités axées sur l'IA ne nécessite aucune expertise en machine learning (ML). Vous n'avez pas besoin de collecter un grand ensemble de données ni d'entraîner un modèle. Pour commencer votre premier programme, il vous suffit de décrire en quelques phrases ce que vous souhaitez que le modèle fasse. Le SDK Vertex AI pour ABAP fournit des classes et des méthodes ABAP permettant d'accéder aux modèles Claude depuis votre environnement SAP.

Avant de commencer

Avant d'utiliser le SDK Vertex AI pour ABAP avec les modèles Claude, assurez-vous que vous ou vos administrateurs avez rempli les conditions préalables suivantes :

• Activé l'API Vertex AI dans votre projet Google Cloud .
• Vous avez activé un modèle Claude compatible depuis Model Garden dans votre projet Google Cloud .
• Installer le SDK Vertex AI pour ABAP dans votre environnement SAP.
• Configurer l'authentification pour accéder à l'API Vertex AI.
• Configurer les paramètres de génération de modèle

Envoyer une demande à Claude

Cette section explique comment envoyer des requêtes aux modèles Claude via l'API Vertex AI à l'aide du SDK Vertex AI pour ABAP.

Instancier la classe d'appelant Claude multimodal

Pour appeler les modèles textuels et multimodaux Claude à l'aide de requêtes textuelles ou multimodales, vous pouvez utiliser la classe /GOOG/CL_MODEL_CLAUDE. Vous instanciez la classe en transmettant la clé de modèle configurée dans les paramètres de génération du modèle :

DATA(lo_model) = NEW /goog/cl_model_claude( iv_model_key = 'MODEL_KEY' ).

Remplacez MODEL_KEY par le nom de la clé du modèle, configuré dans les paramètres de génération du modèle.

Générer du contenu avec une requête

Pour générer du contenu en fournissant une requête textuelle au modèle, vous pouvez utiliser la méthode GENERATE_CONTENT :

lo_model->generate_content( 'PROMPT' ).

Remplacez PROMPT par votre requête textuelle.

Fournir des instructions système au modèle

Pour transmettre des instructions système basées sur du texte au modèle, vous pouvez utiliser la méthode SET_SYSTEM_INSTRUCTIONS :

lo_model->set_system_instructions( 'SYSTEM_INSTRUCTIONS' ).

Remplacez SYSTEM_INSTRUCTIONS par vos instructions système pour le modèle.

Définir la configuration de génération pour le modèle

Vous gérez la configuration de la génération pour les modèles dans le tableau /GOOG/AI_CONFIG. Pour remplacer la configuration de génération d'un appel spécifique, vous pouvez utiliser la méthode SET_GENERATION_CONFIG. Si le paramètre d'importation d'une propriété de génération est défini, la valeur du paramètre transmis est prise en compte.

lo_model->set_generation_config(
                                iv_temperature        = 'TEMPERATURE'
                                iv_top_p              = 'TOP_P'
                                iv_top_k              = 'TOP_K'
                                iv_max_output_tokens  = 'MAX_OUTPUT_TOKENS' ).

Remplacez les éléments suivants :

• TEMPERATURE : température de la randomisation.
• TOP_P : échantillonnage Top-P.
• TOP_K : échantillonnage Top-K.
• MAX_OUTPUT_TOKENS : nombre maximal de jetons de sortie par message

Pour en savoir plus sur ces paramètres, consultez la section Configurer les paramètres de génération de modèles.

Transmettre une entrée multimodale au modèle

Vous pouvez appeler les modèles Gemini à l'aide d'entrées multimodales, qui peuvent être du texte, des images ou des documents. Vous pouvez transmettre des entrées pour les images et les PDF sous forme de données brutes. Pour les PDF, vous pouvez également fournir un URI si le PDF est accessible au public.

Le tableau suivant répertorie les types MIME acceptés :

Type de contenu	Types MIME compatibles
Images	image/jpeg image/png image/gif image/webp
Documents	application/pdf

Définir les données brutes

Pour fournir les données brutes d'un fichier en entrée du modèle, ainsi que son type MIME, vous pouvez utiliser la méthode SET_INLINE_DATA :

lo_model->set_inline_data( iv_mime_type = 'MIME_TYPE'
                          iv_data      = 'RAW_DATA'
                          iv_type      = 'base64' ).

Remplacez les éléments suivants :

• MIME_TYPE : type MIME standard IANA des données brutes. Par défaut, le type MIME est défini sur image/jpeg.
• RAW_DATA : données brutes encodées en base64 de l'image ou du PDF à inclure dans la requête.

Pour effacer les données brutes des fichiers de l'entrée du modèle avec la même instance de la classe /GOOG/CL_MODEL_CLAUDE, vous pouvez utiliser la méthode CLEAR_INLINE_DATA :

lo_model->clear_inline_data( ).

Compter le nombre de jetons dans une requête textuelle

Pour compter le nombre de jetons dans une invite de texte avant d'appeler le modèle avec l'invite, vous pouvez utiliser la méthode COUNT_TOKENS :

DATA(lv_total_tokens) = lo_model->count_tokens( iv_prompt_text         = 'PROMPT'
                                                iv_system_instructions = 'SYSTEM_INSTRUCTIONS'
                              )->get_total_tokens( ).

Remplacez les éléments suivants :

• PROMPT : votre requête de texte.
• SYSTEM_INSTRUCTIONS : vos instructions système pour le modèle.

Ajouter des séquences d'arrêt

Une stop_sequence est un ensemble de chaînes qui indique à Claude d'arrêter la génération lorsqu'il rencontre l'une de ces chaînes dans sa réponse. Il s'agit essentiellement d'une commande qui indique à Claude : "Si tu génères cette séquence, arrête immédiatement !"

L'exemple de code suivant n'inclut pas de stop_sequence :

lv_prompt = 'Generate a JSON object representing a person with a name, email, and phone number'.

lv_response = lo_model->generate_content( lv_prompt )->get_text( ).

Cet exemple de code renvoie la réponse suivante :

{
  "name": "Dana A",
  "email": "[e-mail]",
  "phoneNumber": "800-555-0199"
}

L'exemple de code suivant inclut un stop_sequence :

DATA: lt_stop_sequences TYPE TABLE OF STRING.

lv_prompt = 'Generate a JSON object representing a person with a name, email, and phone number'.

APPEND '}' to lt_stop_sequences.

lv_response = lo_model->set_stop_sequence( lt_stop_sequences
                )->generate_content( lv_prompt
                )->get_text( ).

Cet exemple de code renvoie la réponse suivante :

Voici un objet JSON représentant une personne avec un nom, une adresse e-mail et un numéro de téléphone :

{
  "name": "Dana A",
  "email": "[e-mail]",
  "phoneNumber": "800-555-0199"

Notez que la sortie n'inclut pas la séquence d'arrêt }. Pour l'analyser en tant que JSON, vous devez ajouter la } de fermeture.

Lorsqu'un modèle Claude fournit une réponse, sa propriété stop_reason indique pourquoi le modèle a arrêté de générer du texte.

Pour obtenir le motif d'arrêt, vous pouvez utiliser l'exemple de code suivant :

lv_stop_reason = lo_model->set_stop_sequence( lt_stop_sequences
                )->generate_content( lv_prompt
                )->get_stop_reason( ).

Ajouter des exemples

Le prompting few-shot est une stratégie efficace qui consiste à fournir à un modèle un petit ensemble d'exemples pour guider sa sortie. Pour ce faire, vous pouvez utiliser l'historique des conversations pour fournir ces exemples à Claude.

Par exemple, pour analyser le sentiment d'un tweet à l'aide de Claude, vous pouvez commencer par demander "Analyse le sentiment de ce tweet : ", puis observer le résultat.

lv_prompt = 'The Burger was delicious and my taste buds were on fire, too yummy!'
lv_system_instruction = 'Please do the sentiment analysis of the review'.
lv_response = lo_model->set_system_instructions( lv_system_instructions
                     )->generate_text( lv_prompt
                     )->get_text( ).

Sortie :

# Sentiment Analysis

This tweet expresses a strongly positive sentiment:

- Words like "delicious" and "yummy" directly convey enjoyment
- The phrase "taste buds were on fire" is used positively to indicate intense flavor enjoyment
- The exclamation mark adds enthusiasm
- "too yummy" emphasizes the exceptional quality

Overall, this is a very positive tweet expressing high satisfaction with the burger.

Bien qu'une réponse complète soit utile, une sortie plus concise de Claude est préférable pour l'analyse automatisée des sentiments de nombreux tweets. Vous pouvez standardiser les réponses de Claude sur un seul mot (POSITIF, NEUTRE, NÉGATIF, par exemple) ou sur une valeur numérique (1, 0, -1, par exemple).

lv_prompt = 'The Burger was delicious and my taste buds were on fire, too yummy!'.
lv_response = lo_model->add_examples( iv_input = |Unpopular opinion: Pickles are disgusting. Don't hate me|
        iv_output = |NEGATIVE|
        )->add_examples( iv_input = |I think my love for burgers might be getting out of hand. I just bought a burger sticker for my crocs|
        iv_output =  |POSITIVE|
        )->add_examples( iv_input = |Seriously why would anyone ever eat a brugers?  Those things are unhealthy!|
        iv_output =  |NEGATIVE|
        )->generate_content( lv_prompt
        )->get_text( ).

Sortie :

POSITIVE

Définir le texte de l'assistant

Une autre stratégie courante pour obtenir des résultats très spécifiques consiste à "mettre des mots dans la bouche de Claude". Au lieu de ne fournir que des messages user à Claude, vous pouvez également fournir un message assistant que Claude utilise pour générer une sortie.

Si vous fournissez un message assistant, Claude poursuit la conversation à partir du dernier jeton assistant. N'oubliez pas que vous devez commencer par un message user.

  lv_prompt = 'The fourth nearest planet to sun is: A) Mercury B) Venus C) Mars D ) Andromeda'.
 lv_assistant_text = 'The answer is:'.
    lv_response = lo_model->set_assistant_text( lv_instruction
                                       )->generate_content( lv_prompt
                                       )->get_text( ).

Cet extrait de code affiche le résultat suivant : C) Mars.

Définir la version d'Anthropic

Vous pouvez définir le paramètre anthropic_version. Par défaut, la valeur définie pour ce paramètre est vertex-2023-10-16. Vous n'avez besoin de modifier sa valeur que si vous souhaitez accéder à une autre version Anthropic compatible.

Si vous devez modifier la version d'Anthropic, vous pouvez utiliser la méthode SET_ANTHROPIC_VERSION :

lo_model->set_anthropic_version( 'ANTHROPIC_VERSION' ).

Remplacez ANTHROPIC_VERSION par la version d'Anthropic à utiliser. Pour en savoir plus, consultez la documentation d'Anthropic.

Recevoir une réponse de Claude

Pour recevoir les réponses traitées du modèle et les présenter de manière pertinente pour les développeurs ABAP, le SDK fournit la classe /GOOG/CL_RESPONSE_CLAUDE.

La réponse capturée par la classe /GOOG/CL_RESPONSE_CLAUDE est associée aux requêtes effectuées via les méthodes de la classe /GOOG/CL_MODEL_CLAUDE. Vous pouvez ainsi accéder directement à la réponse dans une seule instruction sans avoir besoin de variables pour stocker les résultats intermédiaires.

Obtenir une réponse textuelle

Pour recevoir une réponse textuelle du modèle, vous pouvez utiliser la méthode GET_TEXT :

DATA(lv_response_text) = lo_model->generate_content( 'PROMPT'
                                )->get_text( ).

Remplacez PROMPT par votre requête textuelle.

Obtenir le nombre de jetons dans la requête

Pour obtenir le nombre de jetons dans l'invite d'entrée du modèle, vous pouvez utiliser la méthode GET_PROMPT_TOKEN_COUNT :

DATA(lv_prompt_token_count) = lo_model->generate_content( 'PROMPT'
                                    )->get_prompt_token_count( ).

Remplacez PROMPT par votre requête textuelle.

Obtenir le nombre de jetons dans la réponse du modèle

Pour obtenir le nombre de jetons dans la réponse du modèle, vous pouvez utiliser la méthode GET_CANDIDATES_TOKEN_COUNT :

DATA(lv_candidates_token_count) = lo_model->generate_content( 'PROMPT'
                                        )->get_candidates_token_count( ).

Remplacez PROMPT par votre requête textuelle.

Obtenir le nombre total de jetons (requête et réponse)

Pour connaître le nombre total de jetons, y compris la requête et la réponse, vous pouvez utiliser la méthode GET_TOTAL_TOKEN_COUNT :

DATA(lv_stop_reason) = lo_model->generate_content( 'PROMPT'
                              )->get_total_token_count( ).

Remplacez PROMPT par votre requête textuelle.

Obtenir le motif de l'arrêt

Pour connaître la raison pour laquelle le modèle a bloqué la génération de la réponse, vous pouvez utiliser la méthode GET_STOP_REASON :

DATA(lv_stop_reason) = lo_model->generate_content( 'PROMPT'
                              )->get_stop_reason( ).
Replace PROMPT with your text prompt.

Remplacez PROMPT par votre requête textuelle.

Exemples de code

Les exemples de code suivants montrent comment appeler les modèles Claude pour générer des réponses à différents types d'entrées.

Génération basée sur du texte

L'exemple de code suivant montre comment générer une réponse à partir d'une requête textuelle accompagnée d'une instruction système. L'instruction système est facultative et peut être transmise avec la requête pour indiquer au modèle comment se comporter.

Exemple de code

DATA:
  lv_instruction TYPE string,
  lv_prompt      TYPE string.

lv_instruction = 'SYSTEM_INSTRUCTIONS'.
lv_prompt      = 'PROMPT'.

TRY.
    DATA(lo_model) = NEW /goog/cl_model_claude( iv_model_key = 'MODEL_KEY' ).

    DATA(lv_response) = lo_model->set_system_instructions( lv_instruction
                              )->generate_content( lv_prompt
                              )->get_text( ).
    IF lv_response IS NOT INITIAL.
      cl_demo_output=>display( lv_response ).

    ENDIF.
  CATCH /goog/cx_sdk INTO DATA(lo_cx_sdk).
    cl_demo_output=>display( lo_cx_sdk->get_text( ) ).

ENDTRY.

Remplacez les éléments suivants :

• MODEL_KEY : nom de la clé du modèle, configuré dans les paramètres de génération du modèle.
• PROMPT : votre requête de texte.
• SYSTEM_INSTRUCTIONS : vos instructions système pour le modèle.

Génération multimodale

L'exemple de code suivant montre comment générer une réponse à partir d'une entrée multimodale, telle que du texte et une image. Vous fournissez l'entrée sous forme de chaîne encodée en base64. Les instructions système sont facultatives et peuvent être transmises avec la requête pour indiquer au modèle comment se comporter.

Exemple de code

DATA:
lv_instruction TYPE string,
lv_prompt      TYPE string.

lv_instruction = 'SYSTEM_INSTRUCTIONS'.
lv_prompt      = 'PROMPT'.

TRY.
    DATA(lo_model) = NEW /goog/cl_model_claude( iv_model_key = 'MODEL_KEY' ).

    DATA(lv_response) = lo_model->set_system_instructions( lv_instruction
                            )->set_inline_data( iv_mime_type = 'MIME_TYPE'
                                                iv_data      = 'INLINE_DATA'
                            )->generate_content( lv_prompt
                            )->get_text( ).
IF lv_response IS NOT INITIAL.
      cl_demo_output=>display( lv_response ).
ENDIF.
  CATCH /goog/cx_sdk INTO DATA(lo_cx_sdk).
    cl_demo_output=>display( lo_cx_sdk->get_text( ) ).
ENDTRY.

Remplacez les éléments suivants :

• MODEL_KEY : nom de la clé du modèle, configuré dans les paramètres de génération du modèle.
• PROMPT : votre requête de texte.
• SYSTEM_INSTRUCTIONS : vos instructions système pour le modèle.
• MIME_TYPE : type MIME standard IANA des données du fichier. Par défaut, le type MIME est défini sur application/pdf.
• INLINE_DATA : données brutes encodées en base64 de l'image ou du PDF à inclure dans la requête.

Trouver le nombre de jetons et de caractères facturables dans une requête

Avant d'appeler le modèle avec une requête, vous pouvez vérifier le nombre de jetons dans votre requête.

Cela vous aide à prendre des décisions éclairées concernant vos requêtes et votre utilisation. Le point de terminaison count-tokens est gratuit. L'exemple de code suivant montre comment trouver ces nombres avant d'appeler l'API :

Exemple de code

DATA:
  lv_prompt      TYPE string.

lv_prompt      = 'PROMPT'.

TRY.
    DATA(lo_model) = NEW /goog/cl_model_claude( iv_model_key = 'MODEL_KEY' ).

    DATA(lv_total_tokens) = lo_model->count_tokens( lv_prompt
                                  )->get_total_tokens( ).

IF lv_total_tokens IS NOT INITIAL.
      cl_demo_output=>display( 'Total Tokens -' && lv_total_tokens ).
ENDIF.

  CATCH /goog/cx_sdk INTO DATA(lo_cx_sdk).
    cl_demo_output=>display( lo_cx_sdk->get_text( ) ).

ENDTRY.

Remplacez les éléments suivants :

• PROMPT : votre requête de texte.
• MODEL_KEY : nom de la clé du modèle, configuré dans les paramètres de génération du modèle.

Étapes suivantes

• Découvrez comment développer des applications avec l'édition sur site ou n'importe quelle édition cloud du SDK ABAP pour Google Cloud.
• Posez vos questions et discutez du SDK Vertex AI pour ABAP avec la communauté sur les forums Cloud.