วิธีโต้ตอบกับ API โดยใช้การเรียกใช้ฟังก์ชันใน Gemini

1. ภาพรวม

การเรียกใช้ฟังก์ชันใน Gemini คืออะไร

Vertex AI Gemini API เป็นตระกูลโมเดล Generative AI ที่พัฒนาโดย Google DeepMind ซึ่งออกแบบมาสำหรับกรณีการใช้งานแบบมัลติโมดัล การเรียกใช้ฟังก์ชันเป็นฟีเจอร์ของโมเดล Gemini ที่ช่วยให้นักพัฒนาแอปรับเอาต์พุตข้อมูลที่มีโครงสร้างจากโมเดล Generative ได้ง่ายขึ้น

จากนั้นนักพัฒนาแอปจะใช้เอาต์พุตเหล่านี้เพื่อเรียก API อื่นๆ และส่งข้อมูลการตอบกลับที่เกี่ยวข้องไปยังโมเดลได้ กล่าวโดยสรุปคือ การเรียกใช้ฟังก์ชันจะช่วยให้คุณเชื่อมต่อโมเดล Generative กับระบบภายนอกได้ เพื่อให้เนื้อหาที่สร้างขึ้นมีข้อมูลที่ถูกต้องและเป็นปัจจุบันมากที่สุด

วิธีการทำงานของการเรียกใช้ฟังก์ชัน

ฟังก์ชันจะอธิบายโดยใช้การประกาศฟังก์ชัน ซึ่งจะช่วยให้โมเดล Generative เข้าใจวัตถุประสงค์และพารามิเตอร์ภายในฟังก์ชัน หลังจากส่งการประกาศฟังก์ชันในคำค้นหาไปยังโมเดล Generative แล้ว โมเดลจะแสดงออบเจ็กต์ที่มีโครงสร้างซึ่งมีชื่อของฟังก์ชันที่เกี่ยวข้องและอาร์กิวเมนต์ของฟังก์ชันเหล่านั้นตามคำค้นหาของผู้ใช้ โปรดทราบว่าการเรียกใช้ฟังก์ชันไม่ได้หมายความว่าโมเดลจะเรียกใช้ฟังก์ชันจริงๆ แต่คุณสามารถใช้ฟังก์ชันและพารามิเตอร์ที่ส่งคืนเพื่อเรียกใช้ฟังก์ชันในภาษา ไลบรารี หรือเฟรมเวิร์กใดก็ได้ที่คุณต้องการ

อินเทอร์เฟซ API

สิ่งที่คุณจะสร้าง

ในโค้ดแล็บนี้ คุณจะได้สร้างไปป์ไลน์ Generative AI ด้วย Vertex AI Gemini API และ Python ผู้ใช้สามารถใช้แอปของคุณเพื่อถามเกี่ยวกับอัตราแลกเปลี่ยน และระบบจะดึงข้อมูลล่าสุดจาก API ภายนอกและตอบคำถามของผู้ใช้

สิ่งที่คุณจะได้เรียนรู้

วิธีโต้ตอบกับโมเดล Gemini โดยใช้ไลบรารีของไคลเอ็นต์ Python
วิธีกำหนดการประกาศฟังก์ชันและลงทะเบียนเป็นเครื่องมือ
วิธีเรียกใช้ Gemini และรับการตอบกลับการเรียกใช้ฟังก์ชัน
วิธีส่งคืนการตอบกลับฟังก์ชันไปยัง Gemini และตอบกลับผู้ใช้

สิ่งที่คุณต้องมี

โปรเจ็กต์ Google Cloud
เบราว์เซอร์ เช่น Chrome
สภาพแวดล้อมการพัฒนา Python เช่น Colab หรือ Colab Enterprise

2. การตั้งค่าและข้อกำหนด

ก่อนที่จะเริ่มใช้การเรียกใช้ฟังก์ชันใน Gemini ได้ คุณต้องเปิดใช้ Vertex AI API และติดตั้งไลบรารีของไคลเอ็นต์ Vertex AI Python เวอร์ชันล่าสุด

เปิดใช้ Vertex AI API

หากต้องการเปิดใช้ Vertex AI API ให้ทำตามขั้นตอนต่อไปนี้

ในเบราว์เซอร์ ให้ไปที่หน้ารายละเอียดบริการ Vertex AI API
คลิกปุ่มเปิดใช้เพื่อเปิดใช้ Vertex AI API ในโปรเจ็กต์ Google Cloud

ติดตั้งไลบรารีของไคลเอ็นต์ Python สำหรับ Vertex AI

หากต้องการติดตั้งไลบรารีของไคลเอ็นต์ Python สำหรับ Vertex AI ให้ทำตามขั้นตอนต่อไปนี้

เปิดเทอร์มินัลในสภาพแวดล้อมการพัฒนา
ตรวจสอบว่าคุณมีสภาพแวดล้อมการพัฒนา Python ที่ถูกต้อง และดูหลักเกณฑ์เหล่านี้หากจำเป็น
เรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งไลบรารีของไคลเอ็นต์ Python สำหรับ Vertex AI
```
pip install --upgrade google-cloud-aiplatform
```
หากคุณใช้งานในสภาพแวดล้อมของ Notebook คุณอาจต้องรีสตาร์ทรันไทม์/เคอร์เนลเพื่อใช้แพ็กเกจที่ติดตั้งใหม่

ตอนนี้คุณพร้อมใช้ Vertex AI API แล้ว

3. ทำความเข้าใจปัญหา

คุณเคยโต้ตอบกับโมเดลภาษาขนาดใหญ่หรือโมเดล Generative AI และถามเกี่ยวกับข้อมูลแบบเรียลไทม์หรือข้อมูลปัจจุบัน แต่กลับได้รับคำตอบที่มีข้อมูลล้าสมัยหรือข้อมูลที่ไม่ถูกต้องไหม

มาลองใช้กันเลย ก่อนอื่น เราจะนำเข้าแพ็กเกจ Python ที่เกี่ยวข้องและเริ่มต้นโมเดล Gemini คุณสามารถเรียกใช้โค้ดต่อไปนี้ในสภาพแวดล้อมการพัฒนา Python เช่น Colab หรือ Colab Enterprise และโดยการติดตั้ง Vertex AI SDK สำหรับ Python เวอร์ชันล่าสุด

import vertexai
from vertexai.generative_models import GenerativeModel
model = GenerativeModel("gemini-1.5-pro-001")

ตอนนี้เรามาถามคำถามเกี่ยวกับอัตราแลกเปลี่ยนของสกุลเงินต่างๆ ในวันนี้กัน

response = model.generate_content(
    "What's the exchange rate for euros to dollars today?"
)
print(response.text)

โมเดลควรสร้างคำตอบที่จำกัดหรือล้าสมัยให้คุณคล้ายกับคำตอบต่อไปนี้

As an AI language model, I don't have access to real-time currency exchange
rates. However, as of my last update in September 2021, the approximate exchange
rate between euros (EUR) and US dollars (USD) was:

1 EUR ≈ 1.18 USD

Please note that currency exchange rates constantly fluctuate and can vary
depending on various factors such as economic conditions, supply and demand,
political events, and more. To obtain the most up-to-date and accurate exchange
rate, I recommend using a reliable currency converter or financial website that
provides live rates.

[...]

หากผู้ใช้ปลายทางได้รับคำตอบประเภทนี้ ผู้ใช้จะต้องเปลี่ยนบริบทเพื่อค้นหาสกุลเงินที่ตนสนใจ ดึงข้อมูลอัตราแลกเปลี่ยนล่าสุด และทำการแปลงค่าด้วยตนเอง

ในอุดมคติแล้ว ไปป์ไลน์โมเดล Generative ควรจัดการงานเหล่านี้บางส่วนหรือทั้งหมดให้ผู้ใช้ได้ ในส่วนถัดไป คุณจะได้ลองวิธีแก้ปัญหาทั่วไปบางอย่างเพื่อให้ได้คำตอบที่มีโครงสร้างจากโมเดล Generative เพื่อให้คุณเรียกใช้ระบบภายนอกได้

4. ลองใช้วิธีแก้ปัญหาทั่วไป

เมื่อทำงานกับโมเดล Generative ในสถานการณ์ที่คุณต้องการข้อมูลหรือข้อมูลล่าสุดจากแหล่งข้อมูลภายนอก คุณสามารถเรียก API ภายนอกแล้วป้อนผลลัพธ์กลับไปยังโมเดล Generative เพื่อให้โมเดลใช้ในคำตอบได้

ก่อนที่จะเรียกใช้ระบบภายนอก คุณต้องพิจารณาฟังก์ชันที่เหมาะสมที่จะใช้ แยกพารามิเตอร์ที่เกี่ยวข้องจากผู้ใช้ และใส่พารามิเตอร์ลงในออบเจ็กต์ข้อมูลที่มีโครงสร้าง ซึ่งมักจะเกี่ยวข้องกับการทำวิศวกรรมพรอมต์อย่างละเอียดเพื่อบังคับให้โมเดล Generative สร้าง Structured Data ที่ถูกต้อง

มาดูคำถามที่เราถามในส่วนก่อนหน้าอีกครั้งและเพิ่มคำสั่งเพิ่มเติมสำหรับโมเดลกัน ลองส่งคำขอต่อไปนี้ไปยังโมเดล Gemini

user_prompt = "What's the exchange rate from euros to US dollars today?"

response = model.generate_content("""
Your task is to extract parameters from the user's input and return it as a
structured JSON payload. The user will ask about the exchange rate and which
currency they are converting from and converting to.

User input: {user_prompt}

Please extract the currencies as parameters and put them in a JSON object.
""".format(user_prompt=user_prompt))
print(response.text)

ซึ่งจะส่งผลให้ได้ข้อความตอบกลับต่อไปนี้ ซึ่งไม่ใช่ JSON ที่ถูกต้องและจะทำให้เราทำงานได้ยาก

```json
{
  "currency_from": "euros",
  "currency_to": "US dollars"
}
```

โดยเฉพาะอย่างยิ่ง บรรทัดแรกและบรรทัดสุดท้ายของการตอบกลับที่เป็นข้อความจะมีเครื่องหมายแบ็กทิกเพื่อคั่นบล็อกโค้ด บรรทัดแรกจะมีตัวระบุภาษา และค่าในออบเจ็กต์ JSON ไม่ใช่ตัวย่อสกุลเงิน 3 ตัวอักษรมาตรฐานที่ API แลกเปลี่ยนสกุลเงินคาดหวังเป็นพารามิเตอร์อินพุต

เราอาจลองใช้ Python เพื่อประมวลผลข้อความนี้เป็น JSON และพจนานุกรมที่ถูกต้อง เพิ่มวิธีการลงในพรอมต์ ระบุตัวอย่างเอาต์พุตที่ต้องการอย่างน้อย 1 รายการ ปรับแต่งโมเดล หรือโทรหาโมเดล Generative อีกครั้งเพื่อขอให้ล้างข้อมูล JSON

แต่ก็มีวิธีที่แน่นอนกว่านี้ มาดูวิธีใช้การเรียกใช้ฟังก์ชันใน Gemini เพื่อค้นหาข้อมูลในบริการภายนอกและแสดงคำตอบที่เกี่ยวข้องแก่ผู้ใช้ปลายทางกัน

5. วิธีการทำงานของการเรียกใช้ฟังก์ชัน

ก่อนที่จะเริ่มการแยกพารามิเตอร์และการเรียกใช้ฟังก์ชัน เรามาดูขั้นตอนการเรียกใช้ฟังก์ชันและคอมโพเนนต์ที่ใช้ในรันไทม์กัน

ภาพรวมของการเรียกใช้ฟังก์ชันใน Gemini

ข้อมูลที่ผู้ใช้ป้อนไปยัง Gemini API

ระบบจะส่งพรอมต์จากผู้ใช้ไปยัง Gemini API และในการเรียก API นั้นไปยังโมเดล Gemini นักพัฒนาซอฟต์แวร์ได้กำหนดการประกาศฟังก์ชันอย่างน้อย 1 รายการภายในเครื่องมือเพื่อให้โมเดล Gemini ทราบว่าฟังก์ชันใดที่เรียกได้และวิธีเรียกฟังก์ชันเหล่านั้น

Gemini API จะแสดงการเรียกฟังก์ชัน

Gemini จะแสดงคำตอบการเรียกใช้ฟังก์ชันพร้อมข้อมูลที่มีโครงสร้างซึ่งมีชื่อของฟังก์ชันที่จะเรียกใช้และพารามิเตอร์ที่เกี่ยวข้องที่จะใช้ โดยอิงตามเนื้อหาของอินพุตและพรอมต์ของผู้ใช้

ส่งคำขอ API

จากนั้นคุณจะใช้ชื่อฟังก์ชันและพารามิเตอร์เพื่อส่งคำขอ API เพื่อดึงข้อมูลจากระบบหรือ API ภายนอก นักพัฒนาแอปจะใช้คำขอและการตอบกลับ API นี้ในโค้ดของแอปพลิเคชัน และจะเกิดขึ้นนอกขอบเขตของ Gemini API และ SDK เช่น คุณอาจใช้ไลบรารี requests ใน Python เพื่อเรียก REST API และรับการตอบกลับ JSON หรือจะเรียกใช้ฟังก์ชันโดยใช้วิธีการและไลบรารีไคลเอ็นต์ที่คุณต้องการก็ได้

ส่งคืนการตอบกลับของ API ไปยัง Gemini

สุดท้าย คุณจะส่งการตอบกลับของ API กลับไปยังโมเดล Gemini เพื่อให้โมเดลสร้างการตอบกลับพรอมต์เริ่มต้นของผู้ใช้ปลายทาง หรือเรียกใช้การตอบกลับการเรียกใช้ฟังก์ชันอื่นหากโมเดล Gemini พิจารณาว่าต้องการข้อมูลเพิ่มเติม

6. เลือก API

ตอนนี้คุณเข้าใจโฟลว์โดยรวมและขั้นตอนที่เฉพาะเจาะจงในการเรียกใช้ฟังก์ชันแล้ว คุณจะสร้างไปป์ไลน์ Generative AI เพื่อดึงอัตราแลกเปลี่ยนสกุลเงินล่าสุด ก่อนอื่น เราต้องเลือก API ที่ต้องการใช้เป็นแหล่งข้อมูล

สำหรับแอปแลกเปลี่ยนสกุลเงิน เราจะใช้ REST API ที่ https://www.frankfurter.app/ เพื่อดึงข้อมูลล่าสุดเกี่ยวกับอัตราแลกเปลี่ยนทั่วโลก

หากต้องการโต้ตอบกับ REST API นี้ เราอาจเรียกใช้ REST API ด้วย requests ใน Python ดังนี้

import requests
url = "https://api.frankfurter.app/latest"
response = requests.get(url)
response.text

หรือคำขอ cURL เช่น

curl https://api.frankfurter.app/latest

ซึ่งจะแสดงการตอบกลับที่คล้ายกับ

{
  "amount": 1,
  "base": "EUR",
  "date": "2023-12-20",
  "rates": {
    "AUD": 1.6186, "BGN": 1.9558, "BRL": 5.3287,
    "CAD": 1.4609, "CHF": 0.946, "CNY": 7.8121,
    "CZK": 24.538, "DKK": 7.4565, "GBP": 0.86555,
    "HKD": 8.5439, "HUF": 385.23, "IDR": 16994,
    "ILS": 3.9983, "INR": 91.06, "ISK": 150.3,
    "JPY": 157.12, "KRW": 1425.62, "MXN": 18.6867,
    "MYR": 5.0977, "NOK": 11.2895, "NZD": 1.7421,
    "PHP": 60.991, "PLN": 4.3413, "RON": 4.9699,
    "SEK": 11.129, "SGD": 1.4562, "THB": 38.252,
    "TRY": 31.883, "USD": 1.0944, "ZAR": 20.111
  }
}

เนื่องจากการเรียกใช้ฟังก์ชันใน Gemini ไม่ได้เรียกใช้ API ภายนอกให้คุณจริงๆ จึงไม่มีข้อจำกัดเกี่ยวกับประเภทของ API ที่คุณใช้ คุณสามารถใช้บริการ Cloud Run, Cloud Function, คำขอ API ไปยังบริการ Google Cloud หรือ REST API ภายนอก

7. กำหนดฟังก์ชันและเครื่องมือ

เมื่อเลือก REST API ที่จะใช้แล้ว ตอนนี้เราก็สามารถกำหนดข้อกำหนด API และลงทะเบียนฟังก์ชันในเครื่องมือได้

ตรวจสอบว่าคุณได้ติดตั้ง Vertex AI SDK สำหรับ Python เวอร์ชันล่าสุดแล้ว

จากนั้นนำเข้าโมดูลที่จำเป็นจาก Python SDK และเริ่มต้นโมเดล Gemini ดังนี้

from vertexai.generative_models import (
    Content,
    FunctionDeclaration,
    GenerativeModel,
    Part,
    Tool,
)

model = GenerativeModel("gemini-1.5-pro-001")

เมื่อกลับไปที่ REST API ที่ https://api.frankfurter.app/ เราจะเห็นว่า API นี้ยอมรับพารามิเตอร์อินพุตต่อไปนี้

พารามิเตอร์	ประเภท	คำอธิบาย
`from`	สตริง	สกุลเงินที่จะแปลง
`to`	สตริง	สกุลเงินที่จะแปลง
`date`	สตริง	วันที่ที่จะดึงอัตราแลกเปลี่ยน

เมื่อใช้พารามิเตอร์เหล่านี้ ข้อมูลจำเพาะของ OpenAPI บางส่วนสำหรับ REST API นี้ในรูปแบบ YAML จะมีลักษณะดังนี้

openapi: 3.0.0
info:
  title: Frankfurter Exchange Rate API
  description: This API provides current and historical exchange rates
  version: 1.0.0
servers:
  - url: https://api.frankfurter.app
paths:
  /{date}:
    get:
      summary: Get the latest currency exchange rates.
      parameters:
        - name: date
          in: path
          description: Get currency rates for a specific date or 'latest' if a date is not specified
          required: true
          schema:
            type: string
        - name: from
          in: query
          description: The currency to convert from.
          required: true
          schema:
            type: string
        - name: to
          in: query
          description: The currency to convert to.
          schema:
            type: string

ตอนนี้มาลงทะเบียนเป็น FunctionDeclaration โดยใช้ Python SDK สำหรับ Gemini กัน

get_exchange_rate_func = FunctionDeclaration(
    name="get_exchange_rate",
    description="Get the exchange rate for currencies between countries",
    parameters={
    "type": "object",
    "properties": {
        "currency_date": {
            "type": "string",
            "description": "A date that must always be in YYYY-MM-DD format or the value 'latest' if a time period is not specified"
        },
        "currency_from": {
            "type": "string",
            "description": "The currency to convert from in ISO 4217 format"
        },
        "currency_to": {
            "type": "string",
            "description": "The currency to convert to in ISO 4217 format"
        }
    },
         "required": [
            "currency_from",
            "currency_date",
      ]
  },
)

โปรดใช้รายละเอียดให้มากที่สุดในคำอธิบายฟังก์ชันและพารามิเตอร์ เนื่องจากโมเดล Generative จะใช้ข้อมูลนี้เพื่อพิจารณาว่าจะเลือกฟังก์ชันใดและจะกรอกพารามิเตอร์ในการเรียกฟังก์ชันอย่างไร

สุดท้าย คุณจะกำหนด Tool ที่มีการประกาศฟังก์ชัน ดังนี้

exchange_rate_tool = Tool(
    function_declarations=[get_exchange_rate_func],
)

ในที่นี้ คุณใช้การประกาศฟังก์ชัน 1 รายการภายในเครื่องมือ แต่โปรดทราบว่าคุณสามารถลงทะเบียนการประกาศฟังก์ชันอย่างน้อย 1 รายการในเครื่องมือ และโมเดลจะเลือกฟังก์ชันที่เหมาะสมเพื่อใช้ในรันไทม์ ดูรายละเอียดเพิ่มเติมเกี่ยวกับ FunctionDeclaration, Tool และคลาสที่เกี่ยวข้องใน Gemini SDK สำหรับ Python ได้ในเอกสารประกอบเกี่ยวกับการเรียกใช้ฟังก์ชันใน Gemini API

คุณกำหนดค่าฟังก์ชันและคำจำกัดความของเครื่องมือเสร็จแล้ว ในส่วนถัดไป เราจะเรียกโมเดล Generative AI ด้วยเครื่องมือนี้และรับการเรียกใช้ฟังก์ชันกลับมา ซึ่งเราจะใช้เพื่อเรียก REST API ได้

8. สร้างการเรียกใช้ฟังก์ชัน

ตอนนี้คุณสามารถป้อนพรอมต์โมเดล Generative AI และใส่ tool ที่คุณกำหนดได้แล้ว

prompt = """What is the exchange rate from Australian dollars to Swedish krona?
How much is 500 Australian dollars worth in Swedish krona?"""

response = model.generate_content(
    prompt,
    tools=[exchange_rate_tool],
)

มาดูออบเจ็กต์การตอบกลับกัน

print(response.candidates[0].content)

role: "model"
parts {
  function_call {
    name: "get_exchange_rate"
    args {
      fields {
        key: "currency_to"
        value {
          string_value: "SEK"
        }
      }
      fields {
        key: "currency_from"
        value {
          string_value: "AUD"
        }
      }
      fields {
        key: "currency_date"
        value {
          string_value: "latest"
        }
      }
    }
  }
}

ดูเหมือนว่าโมเดลจะเลือกฟังก์ชันที่มีอยู่และส่งคืนการเรียกฟังก์ชันสำหรับฟังก์ชัน get_exchange_rate พร้อมกับพารามิเตอร์ และพารามิเตอร์อยู่ในรูปแบบที่ถูกต้องตามที่เราต้องการ ยินดีด้วยที่คุณได้รับคำตอบที่มีโครงสร้างจากโมเดล Generative AI

ในส่วนถัดไป คุณจะใช้ข้อมูลในคำตอบเพื่อส่งคำขอ API

9. ส่งคำขอ API

โปรดทราบว่าการเรียกใช้ฟังก์ชันใน Gemini ไม่ได้เรียกใช้ API ภายนอกให้คุณจริงๆ แต่คุณสามารถใช้ภาษา ไลบรารี หรือเฟรมเวิร์กใดก็ได้ตามต้องการ

ในที่นี้ คุณจะใช้ไลบรารี requests ใน Python เพื่อเรียก REST API ของอัตราแลกเปลี่ยน

มาแยกวิเคราะห์การตอบกลับเป็นพจนานุกรม Python กัน

params = {}
for key, value in response.candidates[0].content.parts[0].function_call.args.items():
    params[key[9:]] = value
params

ตอนนี้เราสามารถเรียกใช้ requests หรือวิธีอื่นๆ ได้แล้ว

import requests
url = f"https://api.frankfurter.app/{params['date']}"
api_response = requests.get(url, params=params)
api_response.text

ซึ่งจะส่งผลให้ได้การตอบกลับที่คล้ายกับ

'{"amount":1.0,"base":"AUD","date":"2024-01-16","rates":{"SEK":6.8682}}'

และเราได้รับการตอบกลับจาก REST API พร้อมข้อมูลอัตราแลกเปลี่ยนล่าสุดของวันนี้ ในส่วนถัดไป เราจะส่งข้อมูลนี้กลับไปยังโมเดลเพื่อให้โมเดลสร้างคำตอบที่เกี่ยวข้องสำหรับผู้ใช้ได้

10. สร้างคำตอบ

สุดท้ายนี้ มาสร้างคำตอบสำหรับผู้ใช้โดยส่งการตอบกลับฟังก์ชันกลับไปยังโมเดลในการสนทนาครั้งถัดไปกัน

response = model.generate_content(
    [
    Content(role="user", parts=[
        Part.from_text(prompt + """Give your answer in steps with lots of detail
            and context, including the exchange rate and date."""),
    ]),
    Content(role="function", parts=[
        Part.from_dict({
            "function_call": {
                "name": "get_exchange_rate",
            }
        })
    ]),
    Content(role="function", parts=[
        Part.from_function_response(
            name="get_exchange_rate",
            response={
                "content": api_response.text,
            }
        )
    ]),
    ],
    tools=[exchange_rate_tool],
)


response.candidates[0].content.parts[0].text

เมื่อส่งการตอบกลับฟังก์ชันกลับไปยังโมเดลแล้ว โมเดลจะตอบกลับพรอมต์ของผู้ใช้พร้อมกับข้อมูลที่เกี่ยวข้องจากการตอบกลับของ API

The exchange rate from Australian dollars to Swedish krona on January 16, 2024,
is 1 Australian dollar is equal to 6.8663 Swedish krona.

So, 500 Australian dollars would be worth 500 * 6.8663 = 3,433.15 Swedish krona.

11. ดูตัวอย่างโค้ดแบบเต็ม

ในขั้นตอนนี้ คุณสามารถใส่โค้ด Python ใน API แบ็กเอนด์โดยใช้บริการ Cloud Run, Cloud Function หรือบริการอื่นๆ ของ Cloud และติดตั้งใช้งานแอปฟรอนท์เอนด์ที่ใช้ API แบ็กเอนด์นี้เพื่อทำการค้นหาโมเดลและการเรียก API

นี่คือตัวอย่างโค้ดแบบเต็มสำหรับโซลูชันสุดท้าย

import requests
from vertexai.generative_models import (
    Content,
    FunctionDeclaration,
    GenerativeModel,
    Part,
    Tool,
)

model = GenerativeModel("gemini-1.5-pro-001")

get_exchange_rate_func = FunctionDeclaration(
    name="get_exchange_rate",
    description="Get the exchange rate for currencies between countries",
    parameters={
    "type": "object",
    "properties": {
        "currency_date": {
            "type": "string",
            "description": "A date that must always be in YYYY-MM-DD format or the value 'latest' if a time period is not specified"
        },
        "currency_from": {
            "type": "string",
            "description": "The currency to convert from in ISO 4217 format"
        },
        "currency_to": {
            "type": "string",
            "description": "The currency to convert to in ISO 4217 format"
        }
    },
         "required": [
            "currency_from",
            "currency_date",
      ]
  },
)

exchange_rate_tool = Tool(
    function_declarations=[get_exchange_rate_func],
)

prompt = """What is the exchange rate from Australian dollars to Swedish krona?
How much is 500 Australian dollars worth in Swedish krona?"""

response = model.generate_content(
    prompt,
    tools=[exchange_rate_tool],
)

response.candidates[0].content

params = {}
for key, value in response.candidates[0].content.parts[0].function_call.args.items():
    params[key[9:]] = value
params

import requests
url = f"https://api.frankfurter.app/{params['date']}"
api_response = requests.get(url, params=params)
api_response.text

response = model.generate_content(
    [
    Content(role="user", parts=[
        Part.from_text(prompt + """Give your answer in steps with lots of detail
            and context, including the exchange rate and date."""),
    ]),
    Content(role="function", parts=[
        Part.from_dict({
            "function_call": {
                "name": "get_exchange_rate",
            }
        })
    ]),
    Content(role="function", parts=[
        Part.from_function_response(
            name="get_exchange_rate",
            response={
                "content": api_response.text,
            }
        )
    ]),
    ],
    tools=[exchange_rate_tool],
)


response.candidates[0].content.parts[0].text

ในการติดตั้งใช้งานนี้ เราใช้คำขอ 2 รายการไปยังโมเดล Generative ได้แก่ คำขอหนึ่งเพื่อสร้างการเรียกใช้ฟังก์ชัน และอีกคำขอหนึ่งเพื่อแสดงผลการตอบกลับของฟังก์ชัน โปรดทราบว่านี่เป็นเพียงวิธีเดียวในการจัดการการเรียกใช้ฟังก์ชันและการตอบกลับฟังก์ชันด้วย Gemini นอกจากนี้ คุณยังเรียกใช้ฟังก์ชันเพิ่มเติมเพื่อรับข้อมูลเพิ่มเติมสำหรับการค้นหา หรือใช้การเรียกใช้ฟังก์ชันกับแชทและวิธีการแบบอะซิงโครนัสได้ด้วย

ดูโค้ดตัวอย่างเพิ่มเติมได้ที่สมุดบันทึกตัวอย่างสำหรับการเรียกใช้ฟังก์ชันใน Gemini

12. ขอแสดงความยินดี

การใช้การเรียกใช้ฟังก์ชันใน Gemini ทำให้คุณสร้างไปป์ไลน์ Generative AI ที่ใช้กับ Vertex AI Gemini API และ Python ได้สำเร็จ ผู้ใช้สามารถถามเกี่ยวกับอัตราแลกเปลี่ยนได้ และระบบจะดึงข้อมูลล่าสุดจาก API ภายนอกและตอบกลับด้วยคำตอบ

เมื่อได้รับพรอมต์จากผู้ใช้ปลายทาง การเรียกใช้ฟังก์ชันใน Gemini จะดูแลการเลือกฟังก์ชันที่เหมาะสม การแยกพารามิเตอร์จากพรอมต์ และการแสดงผลออบเจ็กต์ข้อมูลที่มีโครงสร้างเพื่อให้คุณทำการเรียก API ภายนอกได้

การออกแบบการเรียกใช้ฟังก์ชันใน Gemini มีจุดประสงค์เพื่อมอบสิ่งที่ดีที่สุดจากทั้ง 2 โลกให้คุณในการดึงพารามิเตอร์อย่างแน่นอน ในขณะเดียวกันก็ปล่อยให้โมเดล Generative ทำหน้าที่สรุปและสร้างเนื้อหา คุณสามารถลองใช้ API และพรอมต์อื่นๆ ในไปป์ไลน์ รวมถึงสำรวจฟังก์ชันอื่นๆ ที่เกี่ยวข้องกับ Vertex AI Gemini API ได้

อินเทอร์เฟซ API

ล้าง

คุณสามารถล้างข้อมูลต่อไปนี้เพื่อหลีกเลี่ยงการเรียกเก็บเงินจากบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ใน Codelab นี้

หากไม่ต้องการให้มีการเรียกเก็บเงินจาก Google Cloud โดยไม่จำเป็น ให้ใช้คอนโซล Google Cloud เพื่อลบโปรเจ็กต์
หากต้องการปิดใช้ API สำหรับ Vertex AI ให้ไปที่หน้ารายละเอียดบริการ Vertex AI API แล้วคลิกปิดใช้ API และยืนยัน

ดูข้อมูลเพิ่มเติม

ดูข้อมูลเพิ่มเติมเกี่ยวกับ AI แบบสนทนาและ Generative AI ได้จากคำแนะนำและแหล่งข้อมูลต่อไปนี้

ใบอนุญาต

ผลงานนี้ได้รับอนุญาตภายใต้สัญญาอนุญาตครีเอทีฟคอมมอนส์สำหรับยอมรับสิทธิของผู้สร้าง (Creative Commons Attribution License) 2.0 แบบทั่วไป