Acessar modelos do Gemini em um fluxo de trabalho usando a Vertex AI

A IA generativa na Vertex AI (também conhecida como genAI ou gen AI) oferece acesso aos modelos de IA generativa do Google para várias modalidades (texto, código, imagens, fala). É possível testar e ajustar esses modelos de linguagem grandes (LLMs) e implantá-los para uso em aplicativos com tecnologia de IA. Para mais informações, consulte a Visão geral da IA generativa na Vertex AI.

A Vertex AI tem vários modelos de fundação de IA generativa acessíveis por uma API, incluindo os modelos usados neste guia. Para mais informações sobre como escolher um modelo, consulte Modelos do Google.

Cada modelo é exposto por um endpoint de editor específico do seu projeto doGoogle Cloud . Por isso, não é necessário implantar o modelo de fundação, a menos que você precise ajustá-lo para um caso de uso específico. Você pode enviar um comando para o endpoint do editor. Um comando é uma solicitação de linguagem natural enviada a um LLM para receber uma resposta.

Este tutorial demonstra fluxos de trabalho que geram respostas de modelos da Vertex AI enviando comandos de texto aos endpoints do editor usando um conector do Workflows ou uma solicitação HTTP POST. Para mais informações, consulte a visão geral do conector da API Vertex AI e Fazer uma solicitação HTTP.

É possível implantar e executar cada fluxo de trabalho de forma independente.

Implantar um fluxo de trabalho que descreve uma imagem

Implante um fluxo de trabalho que usa um método de conector (generateContent) para fazer uma solicitação a um endpoint de editor de modelo. O método oferece suporte à geração de conteúdo com entradas multimodais.

O fluxo de trabalho fornece um comando de texto e o URI de uma imagem disponível publicamente em um bucket do Cloud Storage. É possível ver a imagem e, no console Google Cloud , conferir os detalhes do objeto.

O fluxo de trabalho retorna uma descrição da imagem com base na resposta gerada pelo modelo.

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados ao solicitar o LLM e os elementos do corpo da resposta, consulte a referência da API Gemini.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho.

    Acessar fluxos de trabalho

  2. Clique em Criar.

  3. Insira um nome para o novo fluxo de trabalho: describe-image.

  4. Na lista Região, selecione us-central1 (Iowa).

  5. Em Conta de serviço, selecione a conta que você criou antes.

  6. Clique em Próxima.

  7. No editor de fluxo de trabalho, insira a seguinte definição:

    main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "gemini-2.5-flash"
            - text_combined: ""
    - ask_llm:
        call: googleapis.aiplatform.v1.projects.locations.endpoints.generateContent
        args:
            model: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model}
            region: ${location}
            body:
                contents:
                    role: user
                    parts:
                    - fileData:
                        mimeType: image/jpeg
                        fileUri: ${args.image_url}
                    - text: Describe this picture in detail
                generation_config:
                    temperature: 0.4
                    max_output_tokens: 2048
                    top_p: 1
                    top_k: 32
        result: llm_response
    - return_result:
        return:
            image_url: ${args.image_url}
            image_description: ${llm_response.candidates[0].content.parts[0].text}

  8. Clique em Implantar.

gcloud

  1. Crie um arquivo de código-fonte para seu fluxo de trabalho:

    touch describe-image.yaml

  2. Em um editor de texto, copie o seguinte fluxo de trabalho para o arquivo de código-fonte:

    main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "gemini-2.5-flash"
            - text_combined: ""
    - ask_llm:
        call: googleapis.aiplatform.v1.projects.locations.endpoints.generateContent
        args:
            model: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model}
            region: ${location}
            body:
                contents:
                    role: user
                    parts:
                    - fileData:
                        mimeType: image/jpeg
                        fileUri: ${args.image_url}
                    - text: Describe this picture in detail
                generation_config:
                    temperature: 0.4
                    max_output_tokens: 2048
                    top_p: 1
                    top_k: 32
        result: llm_response
    - return_result:
        return:
            image_url: ${args.image_url}
            image_description: ${llm_response.candidates[0].content.parts[0].text}

  3. Implante o fluxo de trabalho digitando o seguinte comando:

    gcloud workflows deploy describe-image \
    --source=describe-image.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Executar o fluxo de trabalho

Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho.

    Acessar fluxos de trabalho

  2. Na página Fluxos de trabalho, selecione o fluxo de trabalho describe-image para acessar a página de detalhes dele.

  3. Na página Detalhes do fluxo de trabalho, clique em Executar.

  4. Em Entrada, digite o seguinte:

    {"image_url":"gs://generativeai-downloads/images/scones.jpg"}

  5. Clique em Executar novamente.

  6. Veja os resultados do fluxo de trabalho no painel Saída.

    A saída será semelhante a esta:

    {
  "image_description": "There are three pink peony flowers on the right side of the picture[]...]There is a white napkin on the table.",
  "image_url": "gs://generativeai-downloads/images/scones.jpg"
}

gcloud

  1. Abra um terminal.

  2. Execute o fluxo de trabalho:

    gcloud workflows run describe-image \
    --data='{"image_url":"gs://generativeai-downloads/images/scones.jpg"}'

    Os resultados da execução serão semelhantes a este:

      Waiting for execution [258b530e-a093-46d7-a4ff-cbf5392273c0] to complete...done.
  argument: '{"image_url":"gs://generativeai-downloads/images/scones.jpg"}'
  createTime: '2024-02-09T13:59:32.166409938Z'
  duration: 4.174708484s
  endTime: '2024-02-09T13:59:36.341118422Z'
  name: projects/1051295516635/locations/us-central1/workflows/describe-image/executions/258b530e-a093-46d7-a4ff-cbf5392273c0
  result: "{\"image_description\":\"The picture shows a rustic table with a white surface,\
    \ on which there are several scones with blueberries, as well as two cups of coffee\
    [...]
    \ on the table. The background of the table is a dark blue color.\",\"image_url\"\
    :\"gs://generativeai-downloads/images/scones.jpg\"}"
  startTime: '2024-02-09T13:59:32.166409938Z'
  state: SUCCEEDED

Implantar um fluxo de trabalho que gere históricos de países

Implante um fluxo de trabalho que faça um loop em uma lista de entrada de países em paralelo e use um método de conector (generateContent) para fazer uma solicitação a um endpoint de editor de modelo. O método oferece suporte à geração de conteúdo com entradas multimodais.

O fluxo de trabalho retorna os históricos de países gerados pelo modelo, combinando-os em um mapa.

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados ao solicitar o LLM e os elementos do corpo da resposta, consulte a referência da API Gemini.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho.

    Acessar fluxos de trabalho

  2. Clique em Criar.

  3. Insira um nome para o novo fluxo de trabalho: gemini-pro-country-histories.

  4. Na lista Região, selecione us-central1 (Iowa).

  5. Em Conta de serviço, selecione a conta que você criou antes.

  6. Clique em Próxima.

  7. No editor de fluxo de trabalho, insira a seguinte definição:

    main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "gemini-2.5-flash"
            - histories: {}
    - loop_over_countries:
        parallel:
            shared: [histories]
            for:
                value: country
                in: ${args.countries}
                steps:
                    - ask_llm:
                        call: googleapis.aiplatform.v1.projects.locations.endpoints.generateContent
                        args:
                            model: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model}
                            region: ${location}
                            body:
                                contents:
                                    role: "USER"
                                    parts:
                                        text: ${"Can you tell me about the history of " + country}
                                generation_config:
                                    temperature: 0.5
                                    max_output_tokens: 2048
                                    top_p: 0.8
                                    top_k: 40
                        result: llm_response
                    - add_to_histories:
                        assign:
                            - histories[country]: ${llm_response.candidates[0].content.parts[0].text}
    - return_result:
        return: ${histories}

  8. Clique em Implantar.

gcloud

  1. Crie um arquivo de código-fonte para seu fluxo de trabalho:

    touch gemini-pro-country-histories.yaml

  2. Em um editor de texto, copie o seguinte fluxo de trabalho para o arquivo de código-fonte:

    main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "gemini-2.5-flash"
            - histories: {}
    - loop_over_countries:
        parallel:
            shared: [histories]
            for:
                value: country
                in: ${args.countries}
                steps:
                    - ask_llm:
                        call: googleapis.aiplatform.v1.projects.locations.endpoints.generateContent
                        args:
                            model: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model}
                            region: ${location}
                            body:
                                contents:
                                    role: "USER"
                                    parts:
                                        text: ${"Can you tell me about the history of " + country}
                                generation_config:
                                    temperature: 0.5
                                    max_output_tokens: 2048
                                    top_p: 0.8
                                    top_k: 40
                        result: llm_response
                    - add_to_histories:
                        assign:
                            - histories[country]: ${llm_response.candidates[0].content.parts[0].text}
    - return_result:
        return: ${histories}

  3. Implante o fluxo de trabalho digitando o seguinte comando:

    gcloud workflows deploy gemini-pro-country-histories \
    --source=gemini-pro-country-histories.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Executar o fluxo de trabalho

Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho.

    Acessar fluxos de trabalho

  2. Na página Fluxos de trabalho, selecione o fluxo de trabalho gemini-pro-country-histories para acessar a página de detalhes dele.

  3. Na página Detalhes do fluxo de trabalho, clique em Executar.

  4. Em Entrada, digite o seguinte:

    {"countries":["Argentina", "Bhutan", "Cyprus", "Denmark", "Ethiopia"]}

  5. Clique em Executar novamente.

  6. Veja os resultados do fluxo de trabalho no painel Saída.

    A saída será semelhante a esta:

    {
  "Argentina": "The history of Argentina is a complex and fascinating one, marked by periods of prosperity and decline, political [...]
  "Bhutan": "The history of Bhutan is a rich and fascinating one, dating back to the 7th century AD. Here is a brief overview: [...]
  "Cyprus": "The history of Cyprus is a long and complex one, spanning over 10,000 years. The island has been ruled by a succession [...]
  "Denmark": "1. **Prehistory and Early History (c. 12,000 BC - 800 AD)**\\n   - The earliest evidence of human habitation in Denmark [...]
  "Ethiopia": "The history of Ethiopia is a long and complex one, stretching back to the earliest human civilizations. The country is [...]
}

gcloud

  1. Abra um terminal.

  2. Execute o fluxo de trabalho:

    gcloud workflows run gemini-pro-country-histories \
    --data='{"countries":["Argentina", "Bhutan", "Cyprus", "Denmark", "Ethiopia"]}' \
    --location=us-central1

    Os resultados da execução serão semelhantes a este:

      Waiting for execution [7ae1ccf1-29b7-4c2c-99ec-7a12ae289391] to complete...done.
  argument: '{"countries":["Argentina","Bhutan","Cyprus","Denmark","Ethiopia"]}'
  createTime: '2024-02-09T16:25:16.742349156Z'
  duration: 12.075968673s
  endTime: '2024-02-09T16:25:28.818317829Z'
  name: projects/1051295516635/locations/us-central1/workflows/gemini-pro-country-histories/executions/7ae1ccf1-29b7-4c2c-99ec-7a12ae289391
  result: "{\"Argentina\":\"The history of Argentina can be traced back to the arrival\
    [...]
    n* 2015: Argentina elects Mauricio Macri as president.\",\"Bhutan\":\"The history\
    [...]
    \ natural beauty, ancient monasteries, and friendly people.\",\"Cyprus\":\"The history\
    [...]
    ,\"Denmark\":\"The history of Denmark can be traced back to the Stone Age, with\
    [...]
    \ a high standard of living.\",\"Ethiopia\":\"The history of Ethiopia is long and\
    [...]
  startTime: '2024-02-09T16:25:16.742349156Z'
  state: SUCCEEDED

Implantar um fluxo de trabalho que resume um documento grande

Implante um fluxo de trabalho que divide um documento grande em partes menores, fazendo solicitações http.post a um endpoint de editor de modelo em paralelo para que o modelo possa resumir cada parte simultaneamente. Por fim, o fluxo de trabalho combina todos os resumos parciais em um completo.

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados ao solicitar o LLM e os elementos do corpo da resposta, consulte a referência da API Gemini.

A definição do fluxo de trabalho pressupõe que você criou um bucket do Cloud Storage para fazer upload de um arquivo de texto. Para mais informações sobre o conector do Workflows (googleapis.storage.v1.objects.get) usado para recuperar objetos do bucket do Cloud Storage, consulte a referência de conectores.

Depois de implantar o fluxo de trabalho, é possível executá-lo criando um acionador do Eventarc adequado e fazendo upload de um arquivo para o bucket. Para mais informações, consulte Rotear eventos do Cloud Storage para o Workflows. Outras APIs precisam ser ativadas e outras funções precisam ser concedidas, incluindo a função de usuário do objeto do Storage (roles/storage.objectUser) à sua conta de serviço, que permite usar objetos do Cloud Storage. Para mais informações, consulte a seção Preparar para criar um gatilho.

Console

  1. No console Google Cloud , acesse a página Fluxos de trabalho.

    Acessar fluxos de trabalho

  2. Clique em Criar.

  3. Insira um nome para o novo fluxo de trabalho: gemini-pro-summaries.

  4. Na lista Região, selecione us-central1 (Iowa).

  5. Em Conta de serviço, selecione a conta que você criou antes.

  6. Clique em Próxima.

  7. No editor de fluxo de trabalho, insira a seguinte definição:

    main:
    params: [input]
    steps:
    - assign_file_vars:
        assign:
            - file_size: ${int(input.data.size)}
            - chunk_size: 64000
            - n_chunks: ${int(file_size / chunk_size)}
            - summaries: []
            - all_summaries_concatenated: ""
    - loop_over_chunks:
        parallel:
            shared: [summaries]
            for:
                value: chunk_idx
                range: ${[0, n_chunks]}
                steps:
                    - assign_bounds:
                        assign:
                            - lower_bound: ${chunk_idx * chunk_size}
                            - upper_bound: ${(chunk_idx + 1) * chunk_size}
                            - summaries: ${list.concat(summaries, "")}
                    - dump_file_content:
                        call: http.get
                        args:
                            url: ${"https://storage.googleapis.com/storage/v1/b/" + input.data.bucket + "/o/" + input.data.name + "?alt=media"}
                            auth:
                                type: OAuth2
                            headers:
                                Range: ${"bytes=" + lower_bound + "-" + upper_bound}
                        result: file_content
                    - assign_chunk:
                        assign:
                            - chunk: ${file_content.body}
                    - generate_chunk_summary:
                        call: ask_gemini_for_summary
                        args:
                            textToSummarize: ${chunk}
                        result: summary
                    - assign_summary:
                        assign:
                            - summaries[chunk_idx]: ${summary}
    - concat_summaries:
        for:
            value: summary
            in: ${summaries}
            steps:
                - append_summaries:
                    assign:
                        - all_summaries_concatenated: ${all_summaries_concatenated + "\n" + summary}
    - reduce_summary:
        call: ask_gemini_for_summary
        args:
            textToSummarize: ${all_summaries_concatenated}
        result: final_summary
    - return_result:
        return:
            - summaries: ${summaries}
            - final_summary: ${final_summary}

ask_gemini_for_summary:
    params: [textToSummarize]
    steps:
        - init:
            assign:
                - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
                - location: "us-central1"
                - model: "gemini-2.5-pro"
                - summary: ""
        - call_gemini:
            call: http.post
            args:
                url: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":generateContent"}
                auth:
                    type: OAuth2
                body:
                    contents:
                        role: user
                        parts:
                            - text: '${"Make a summary of the following text:\n\n" + textToSummarize}'
                    generation_config:
                        temperature: 0.2
                        maxOutputTokens: 2000
                        topK: 10
                        topP: 0.9
            result: gemini_response
        # Sometimes, there's no text, for example, due to safety settings
        - check_text_exists:
            switch:
            - condition: ${not("parts" in gemini_response.body.candidates[0].content)}
              next: return_summary
        - extract_text:
            assign:
                - summary: ${gemini_response.body.candidates[0].content.parts[0].text}
        - return_summary:
            return: ${summary}

  8. Clique em Implantar.

gcloud

  1. Crie um arquivo de código-fonte para seu fluxo de trabalho:

    touch gemini-pro-summaries.yaml

  2. Em um editor de texto, copie o seguinte fluxo de trabalho para o arquivo de código-fonte:

    main:
    params: [input]
    steps:
    - assign_file_vars:
        assign:
            - file_size: ${int(input.data.size)}
            - chunk_size: 64000
            - n_chunks: ${int(file_size / chunk_size)}
            - summaries: []
            - all_summaries_concatenated: ""
    - loop_over_chunks:
        parallel:
            shared: [summaries]
            for:
                value: chunk_idx
                range: ${[0, n_chunks]}
                steps:
                    - assign_bounds:
                        assign:
                            - lower_bound: ${chunk_idx * chunk_size}
                            - upper_bound: ${(chunk_idx + 1) * chunk_size}
                            - summaries: ${list.concat(summaries, "")}
                    - dump_file_content:
                        call: http.get
                        args:
                            url: ${"https://storage.googleapis.com/storage/v1/b/" + input.data.bucket + "/o/" + input.data.name + "?alt=media"}
                            auth:
                                type: OAuth2
                            headers:
                                Range: ${"bytes=" + lower_bound + "-" + upper_bound}
                        result: file_content
                    - assign_chunk:
                        assign:
                            - chunk: ${file_content.body}
                    - generate_chunk_summary:
                        call: ask_gemini_for_summary
                        args:
                            textToSummarize: ${chunk}
                        result: summary
                    - assign_summary:
                        assign:
                            - summaries[chunk_idx]: ${summary}
    - concat_summaries:
        for:
            value: summary
            in: ${summaries}
            steps:
                - append_summaries:
                    assign:
                        - all_summaries_concatenated: ${all_summaries_concatenated + "\n" + summary}
    - reduce_summary:
        call: ask_gemini_for_summary
        args:
            textToSummarize: ${all_summaries_concatenated}
        result: final_summary
    - return_result:
        return:
            - summaries: ${summaries}
            - final_summary: ${final_summary}

ask_gemini_for_summary:
    params: [textToSummarize]
    steps:
        - init:
            assign:
                - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
                - location: "us-central1"
                - model: "gemini-2.5-pro"
                - summary: ""
        - call_gemini:
            call: http.post
            args:
                url: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":generateContent"}
                auth:
                    type: OAuth2
                body:
                    contents:
                        role: user
                        parts:
                            - text: '${"Make a summary of the following text:\n\n" + textToSummarize}'
                    generation_config:
                        temperature: 0.2
                        maxOutputTokens: 2000
                        topK: 10
                        topP: 0.9
            result: gemini_response
        # Sometimes, there's no text, for example, due to safety settings
        - check_text_exists:
            switch:
            - condition: ${not("parts" in gemini_response.body.candidates[0].content)}
              next: return_summary
        - extract_text:
            assign:
                - summary: ${gemini_response.body.candidates[0].content.parts[0].text}
        - return_summary:
            return: ${summary}

  3. Implante o fluxo de trabalho digitando o seguinte comando:

    gcloud workflows deploy gemini-pro-summaries \
    --source=gemini-pro-summaries.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com