1. ภาพรวม
การเรียกใช้ฟังก์ชันใน Gemini คืออะไร
Vertex AI Gemini API คือตระกูลโมเดล Generative AI ที่พัฒนาโดย Google DeepMind ซึ่งออกแบบมาสำหรับกรณีการใช้งานหลายรูปแบบ การเรียกใช้ฟังก์ชันเป็นฟีเจอร์ของโมเดล Gemini ที่ช่วยให้นักพัฒนาแอปรับเอาต์พุต Structured Data จากโมเดล Generative ได้ง่ายขึ้น
จากนั้นนักพัฒนาซอฟต์แวร์จะใช้เอาต์พุตเหล่านี้เพื่อเรียกใช้ API อื่นๆ และส่งข้อมูลการตอบกลับที่เกี่ยวข้องไปยังโมเดลได้ กล่าวคือ การเรียกใช้ฟังก์ชันช่วยให้คุณเชื่อมต่อโมเดล Generative กับระบบภายนอกเพื่อให้เนื้อหาที่สร้างขึ้นมีข้อมูลที่ถูกต้องและเป็นปัจจุบันที่สุด
วิธีการทำงานของการเรียกใช้ฟังก์ชัน
มีการอธิบายฟังก์ชันโดยใช้การประกาศฟังก์ชัน ซึ่งช่วยให้โมเดล Generative เข้าใจวัตถุประสงค์และพารามิเตอร์ภายในฟังก์ชัน หลังจากที่คุณส่งการประกาศฟังก์ชันในการค้นหาไปยังโมเดล Generative แล้ว โมเดลจะแสดงผลออบเจ็กต์ที่มีโครงสร้างซึ่งมีชื่อของฟังก์ชันที่เกี่ยวข้องและอาร์กิวเมนต์โดยอิงตามการค้นหาของผู้ใช้ โปรดทราบว่าในการเรียกฟังก์ชัน โมเดลจะไม่ได้เรียกใช้ฟังก์ชันนั้นจริงๆ แต่คุณสามารถใช้ฟังก์ชันและพารามิเตอร์ที่แสดงผลเพื่อเรียกฟังก์ชันในภาษา ไลบรารี หรือเฟรมเวิร์กที่คุณต้องการ
สิ่งที่คุณจะสร้าง
ใน Codelab นี้ คุณจะได้สร้างไปป์ไลน์ 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 - หากกำลังใช้สภาพแวดล้อมสมุดบันทึก คุณอาจต้องรีสตาร์ทรันไทม์/เคอร์เนลเพื่อใช้แพ็กเกจที่ติดตั้งใหม่
ตอนนี้คุณพร้อมที่จะใช้ 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 แสดงผลข้อมูลที่มีโครงสร้างที่ถูกต้อง
เรามาทบทวนคำถามที่เราถามในส่วนก่อนหน้านี้อีกครั้ง และเพิ่มคำแนะนำเพิ่มเติมสำหรับโมเดลกัน ลองส่งคำขอต่อไปนี้ไปยังโมเดล 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 ไม่ใช่ตัวย่อสกุลเงินสามตัวอักษรมาตรฐานที่ API การแลกเปลี่ยนสกุลเงินคาดว่าจะเป็นพารามิเตอร์อินพุต
เราอาจลองใช้ Python เพื่อประมวลผลข้อความนี้เป็น JSON และพจนานุกรมที่ถูกต้อง เพิ่มคำสั่งในพรอมต์ ให้ตัวอย่างเอาต์พุตที่ต้องการอย่างน้อย 1 ตัวอย่าง ปรับแต่งโมเดล หรือเรียกโมเดล Generative อีกครั้งเพื่อขอให้ล้าง JSON
แต่ยังมีวิธีที่ตายตัวมากกว่า! มาเรียนรู้วิธีใช้การเรียกใช้ฟังก์ชันใน Gemini เพื่อค้นหาข้อมูลในบริการภายนอกและแสดงผลคำตอบที่เกี่ยวข้องให้กับผู้ใช้ปลายทางกัน
5. วิธีการทำงานของการเรียกใช้ฟังก์ชัน
ก่อนที่เราจะเริ่มต้นการดึงข้อมูลพารามิเตอร์และการเรียกใช้ฟังก์ชัน เราจะมาดูขั้นตอนการเรียกฟังก์ชันและคอมโพเนนต์ที่ใช้ในระหว่างรันไทม์กัน
ข้อมูลจากผู้ใช้เกี่ยวกับ 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. กำหนดฟังก์ชันและเครื่องมือ
เมื่อคุณได้เลือก API ของ REST ที่จะใช้แล้ว เราจึงสามารถตั้งข้อกำหนด 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/ เราจะเห็นว่าโปรแกรมยอมรับพารามิเตอร์อินพุตต่อไปนี้
พารามิเตอร์ | ประเภท | คำอธิบาย |
| สตริง | สกุลเงินที่ใช้แปลง |
| สตริง | สกุลเงินที่ต้องการแปลงเป็น |
| สตริง | วันที่ที่จะดึงข้อมูลอัตราแลกเปลี่ยน |
เมื่อใช้พารามิเตอร์เหล่านี้ ข้อมูลจำเพาะของ 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 รายการในเครื่องมือ และโมเดลจะเลือกฟังก์ชันที่เหมาะสมเพื่อใช้ขณะรันไทม์ โปรดดูเอกสารประกอบเกี่ยวกับการเรียกใช้ฟังก์ชันใน Gemini API เพื่อดูรายละเอียดเพิ่มเติมเกี่ยวกับ FunctionDeclaration, Tool และคลาสที่เกี่ยวข้องใน Gemini SDK สำหรับ Python
คุณกำหนดค่าการกำหนดฟังก์ชันและเครื่องมือเสร็จสมบูรณ์แล้ว ในส่วนถัดไป เราจะเรียกโมเดล Generative ด้วยเครื่องมือนี้ และเรียกฟังก์ชันที่เราสามารถใช้เรียก REST API ได้
8. สร้างการเรียกใช้ฟังก์ชัน
ตอนนี้คุณสามารถเรียกใช้โมเดล Generative และรวม 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"
}
}
}
}
}
ดูเหมือนว่าโมเดลจะเลือกฟังก์ชันที่พร้อมใช้งาน 1 รายการและแสดงผลการเรียกใช้ฟังก์ชันสำหรับฟังก์ชัน get_exchange_rate พร้อมกับพารามิเตอร์ และพารามิเตอร์อยู่ในรูปแบบที่ถูกต้องตามที่เราต้องการ เยี่ยมเลยที่ได้รับคำตอบที่มีโครงสร้างจากโมเดล Generative
ในส่วนถัดไป คุณจะใช้ข้อมูลในการตอบกลับเพื่อสร้างคำขอ API
9. ส่งคำขอ API
แต่อย่าลืมว่าการเรียกใช้ฟังก์ชันใน Gemini ไม่ได้เรียก API ภายนอกให้คุณจริงๆ แต่จะใช้ภาษา ไลบรารี หรือเฟรมเวิร์กที่คุณต้องการก็ได้
คุณจะใช้ไลบรารี requests ใน Python เพื่อเรียกใช้ API ของ REST สำหรับอัตราแลกเปลี่ยน
ลองแยกคำตอบลงในพจนานุกรม 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 หรือบริการอื่นๆ ในระบบคลาวด์ แล้วทำให้แอปฟรอนท์เอนด์ที่ใช้ 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 จะดูแลการเลือกฟังก์ชันที่เหมาะสม แยกพารามิเตอร์จากพรอมต์ และส่งคืนออบเจ็กต์ Structured Data ให้คุณเพื่อทำการเรียก API ภายนอก
การออกแบบการเรียกใช้ฟังก์ชันใน Gemini มีวัตถุประสงค์เพื่อมอบสิ่งที่ดีที่สุดจากทั้ง 2 อย่างสำหรับการดึงพารามิเตอร์ที่กำหนด ขณะเดียวกันก็ปล่อยให้การสรุปและการสร้างเนื้อหาไว้ในโมเดล Generative ลองใช้ API และพรอมต์อื่นๆ ในไปป์ไลน์ของคุณ และสำรวจฟังก์ชันการทำงานอื่นๆ ที่พร้อมใช้งานซึ่งเกี่ยวข้องกับ Vertex AI Gemini API ได้ทุกเมื่อ
ล้างข้อมูล
คุณสามารถดำเนินการทำความสะอาดต่อไปนี้เพื่อเลี่ยงไม่ให้เกิดการเรียกเก็บเงินกับบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ใน Codelab นี้
- หากต้องการหลีกเลี่ยงการเรียกเก็บเงินจาก Google Cloud โดยไม่จำเป็น ให้ใช้คอนโซล Google Cloud เพื่อลบโปรเจ็กต์หากไม่ต้องการใช้
- หากต้องการปิดใช้ API สำหรับ Vertex AI ให้ไปที่หน้ารายละเอียดบริการ Vertex AI API แล้วคลิกปิดใช้ API แล้วยืนยัน
ดูข้อมูลเพิ่มเติม
เรียนรู้ต่อไปเกี่ยวกับ AI แบบสนทนาและ Generative AI ด้วยคำแนะนำและแหล่งข้อมูลเหล่านี้
- ภาพรวมของโมเดล Gemini
- เอกสารประกอบสำหรับการเรียกใช้ฟังก์ชันใน Gemini
- ตัวอย่างสมุดบันทึกสำหรับการเรียกใช้ฟังก์ชันใน Gemini
- ตัวอย่างสมุดบันทึกสำหรับ Gemini
- Generative AI ใน Google Cloud
ใบอนุญาต
ผลงานนี้ได้รับอนุญาตภายใต้ใบอนุญาตทั่วไปครีเอทีฟคอมมอนส์แบบระบุแหล่งที่มา 2.0