Invocar os modelos Claude da Anthropic

Neste documento, descrevemos como invocar os modelos do Anthropic Claude para gerar respostas para entradas de texto e multimodais usando o SDK da Vertex AI para ABAP. Os modelos do Claude aceitam vários modos de entrada, incluindo texto, imagem e documentos. É possível usar os modelos do Claude em casos de uso como os seguintes:

  • Resumir texto livre
  • Descrever ou interpretar recursos de mídia
  • Tradução entre idiomas

Usar modelos generativos para criar recursos centrados em IA não exige experiência em machine learning (ML). Não é necessário coletar um grande conjunto de dados nem treinar um modelo. Para começar seu primeiro programa, basta descrever o que você quer que o modelo faça em algumas frases. O SDK da Vertex AI para ABAP fornece classes e métodos ABAP para acessar os modelos do Claude no seu ambiente SAP.

Antes de começar

Antes de usar o SDK da Vertex AI para ABAP com os modelos do Claude, confira se você ou seus administradores cumpriram os seguintes pré-requisitos:

Enviar solicitação para o Claude

Nesta seção, explicamos como enviar solicitações aos modelos do Claude pela API Vertex AI usando o SDK da Vertex AI para ABAP.

Instanciar a classe invocadora multimodal do Claude

Para invocar os modelos de texto e multimodais do Claude usando comandos de texto ou multimodais, use a classe /GOOG/CL_MODEL_CLAUDE. Para instanciar a classe, transmita a chave do modelo configurada nos parâmetros de geração de modelos:

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

Substitua MODEL_KEY pelo nome da chave do modelo, que é configurado nos parâmetros de geração de modelo.

Gerar conteúdo com um comando

Para gerar conteúdo fornecendo um comando de texto ao modelo, use o método GENERATE_CONTENT:

lo_model->generate_content( 'PROMPT' ).

Substitua PROMPT pelo seu comando de texto.

Fornecer instruções do sistema ao modelo

Para transmitir instruções do sistema baseadas em texto ao modelo, use o método SET_SYSTEM_INSTRUCTIONS:

lo_model->set_system_instructions( 'SYSTEM_INSTRUCTIONS' ).

Substitua SYSTEM_INSTRUCTIONS pelas instruções do sistema para o modelo.

Definir a configuração de geração para o modelo

Você mantém a configuração de geração para os modelos na tabela /GOOG/AI_CONFIG. Para substituir a configuração de geração de uma chamada específica, use o método SET_GENERATION_CONFIG. Se o parâmetro de importação de uma propriedade de geração estiver definido, o valor do parâmetro transmitido será usado.

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' ).

Substitua:

  • TEMPERATURE: temperatura de aleatoriedade.
  • TOP_P: amostragem Top-P.
  • TOP_K: amostragem Top-K.
  • MAX_OUTPUT_TOKENS: número máximo de tokens de saída por mensagem

Para mais informações sobre esses parâmetros, consulte Configurar parâmetros de geração de modelo.

Transmitir entrada multimodal para o modelo

Você pode invocar os modelos do Gemini usando entrada multimodal, que pode ser texto, imagem ou documentos. É possível transmitir entradas de imagens e PDFs como dados brutos. Para PDFs, também é possível fornecer um URI se o PDF estiver acessível ao público.

A tabela a seguir lista os tipos MIME compatíveis:

Tipo de mídia Tipos MIME compatíveis
Imagens
  • image/jpeg
  • image/png
  • image/gif
  • image/webp
Documentos
  • application/pdf

Definir dados brutos

Para fornecer os dados brutos de um arquivo como entrada para o modelo, junto com o tipo MIME, use o método SET_INLINE_DATA:

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

Substitua:

  • MIME_TYPE: o tipo MIME padrão IANA dos dados brutos. Por padrão, o tipo MIME é definido como image/jpeg.
  • RAW_DATA: dados brutos codificados em base64 da imagem ou do PDF a ser incluído in-line no comando.

Para limpar os dados brutos de arquivos da entrada do modelo com a mesma instância da classe /GOOG/CL_MODEL_CLAUDE, use o método CLEAR_INLINE_DATA:

lo_model->clear_inline_data( ).

Contar o número de tokens em um comando de texto

Para contar o número de tokens em um comando de texto antes de invocar o modelo com o comando, use o método COUNT_TOKENS:

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

Substitua:

Adicionar sequências de paradas

Uma stop_sequence é um conjunto de strings que instrui o Claude a interromper a geração ao encontrar qualquer uma dessas strings na resposta. Basicamente, é um comando que diz ao Claude: "Se você gerar esta sequência, pare imediatamente!"

O exemplo de código a seguir não inclui um 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( ).

Este exemplo de código retorna a seguinte resposta:

{
  "name": "Dana A",
  "email": "dana@example.com",
  "phoneNumber": "800-555-0199"
}

O exemplo de código a seguir inclui um 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( ).

Este exemplo de código retorna a seguinte resposta:

Este é um objeto JSON que representa uma pessoa com nome, e-mail e número de telefone:

{
  "name": "Dana A",
  "email": "dana@example.com",
  "phoneNumber": "800-555-0199"

Observe que a saída não inclui a sequência de paradas }. Para analisar isso como JSON, adicione o } de fechamento.

Quando um modelo do Claude fornece uma resposta, a propriedade stop_reason indica por que o modelo parou de gerar texto.

Para saber o motivo da interrupção, use o exemplo de código a seguir:

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

Adicionar exemplos

Os comandos de poucos disparos são uma estratégia eficaz em que você fornece a um modelo um pequeno conjunto de exemplos para orientar a saída dele. Para isso, use o histórico de conversas e forneça esses exemplos ao Claude.

Por exemplo, para analisar o sentimento de um tweet usando o Claude, comece perguntando: "Analise o sentimento neste tweet: " e observe a saída resultante.

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( ).

Saída:

# 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.

Embora uma resposta abrangente seja valiosa, para a análise de sentimento automatizada de vários tweets, é preferível uma saída mais concisa do Claude. Você pode padronizar as respostas da Claude para uma única palavra, como POSITIVO, NEUTRO, NEGATIVO, ou um valor numérico, como 1, 0, -1.

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( ).

Saída:

POSITIVE

Definir texto do assistente

Outra estratégia comum para receber resultados muito específicos é "colocar palavras na boca do Claude". Em vez de apenas fornecer mensagens user para o Claude, você também pode fornecer uma mensagem assistant que o Claude usa ao gerar a saída.

Se você fornecer uma mensagem assistant, o Claude vai continuar a conversa do último token assistant. Lembre-se de que você precisa começar com uma mensagem 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( ).

Este snippet de código mostra a seguinte saída: C) Mars.

Definir a versão do Anthropic

É possível definir o parâmetro anthropic_version. Por padrão, vertex-2023-10-16 é o valor definido para esse parâmetro. Só é necessário mudar o valor se você quiser acessar outra versão compatível da Anthropic.

Se você precisar mudar a versão da Anthropic, use o método SET_ANTHROPIC_VERSION:

lo_model->set_anthropic_version( 'ANTHROPIC_VERSION' ).

Substitua ANTHROPIC_VERSION pela versão da Anthropic a ser usada. Para mais informações, consulte a documentação do Anthropic.

Receber resposta do Claude

Para receber respostas processadas do modelo e apresentá-las de uma maneira significativa para desenvolvedores ABAP, o SDK fornece a classe /GOOG/CL_RESPONSE_CLAUDE.

A resposta capturada pela classe /GOOG/CL_RESPONSE_CLAUDE é encadeada às solicitações feitas pelos métodos da classe /GOOG/CL_MODEL_CLAUDE. Assim, é possível acessar diretamente a resposta em uma única instrução sem exigir variáveis para armazenar os resultados intermediários.

Receber resposta de texto

Para receber uma resposta de texto do modelo, use o método GET_TEXT:

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

Substitua PROMPT pelo seu comando de texto.

Receber o número de tokens no comando da solicitação

Para receber o número de tokens no comando de entrada para o modelo, use o método GET_PROMPT_TOKEN_COUNT:

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

Substitua PROMPT pelo seu comando de texto.

Receber o número de tokens na resposta do modelo

Para receber o número de tokens na resposta do modelo, use o método GET_CANDIDATES_TOKEN_COUNT:

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

Substitua PROMPT pelo seu comando de texto.

Receber a contagem total de tokens (solicitação e resposta)

Para determinar a contagem agregada de tokens, que abrange a solicitação e a resposta, use o método GET_TOTAL_TOKEN_COUNT:

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

Substitua PROMPT pelo seu comando de texto.

Receber motivo da parada

Para receber o motivo pelo qual o modelo bloqueou a geração de respostas, use o método GET_STOP_REASON:

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

Substitua PROMPT pelo seu comando de texto.

Amostras de código

Os exemplos de código a seguir demonstram como invocar os modelos do Claude para gerar respostas a vários tipos de entrada.

Geração com base em texto

O exemplo de código a seguir mostra como gerar uma resposta de um comando de texto com uma instrução do sistema. A instrução do sistema é opcional e pode ser transmitida com o comando para instruir o modelo a se comportar de uma maneira específica.

Exemplo de código

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.

Substitua:

Geração multimodal

O exemplo de código a seguir mostra como gerar uma resposta com base em uma entrada multimodal, como texto e imagem. Você fornece a entrada como uma string codificada em base64. A instrução do sistema é opcional e pode ser transmitida com o comando para instruir o modelo a se comportar de uma maneira específica.

Exemplo de código

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.

Substitua:

  • MODEL_KEY: o nome da chave do modelo, que é configurado nos parâmetros de geração de modelo.
  • PROMPT: seu comando de texto.
  • SYSTEM_INSTRUCTIONS: suas instruções do sistema para o modelo.
  • MIME_TYPE: o tipo MIME padrão da IANA dos dados do arquivo. Por padrão, o tipo MIME é definido como application/pdf.
  • INLINE_DATA: dados brutos codificados em base64 da imagem ou do PDF a serem incluídos inline no comando.

Encontrar o número de tokens e caracteres faturáveis em um comando

Antes de invocar o modelo com um comando, confira o número de tokens no comando.

Isso ajuda você a tomar decisões informadas sobre seus comandos e uso. Não há custo para o endpoint "count-tokens". O exemplo de código a seguir mostra como encontrar esses números antes de invocar a API:

Exemplo de código

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.

Substitua:

A seguir