ดูตำราอาหาร Gemini API และฟอรัมชุมชนของเรา

หน้านี้ได้รับการแปลโดย Cloud Translation API

เริ่มต้นใช้งาน Gemini API ในแอปพลิเคชัน Go

บทแนะนำนี้จะสาธิตวิธีเข้าถึง Gemini API สำหรับแอปพลิเคชัน Go โดยใช้ Google AI Go SDK

ในบทแนะนำนี้ คุณจะได้เรียนรู้วิธีทำสิ่งต่อไปนี้

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

บทแนะนำนี้ยังประกอบด้วยส่วนต่างๆ เกี่ยวกับกรณีการใช้งานขั้นสูง (เช่น การฝังและโทเค็นการนับ) รวมถึงตัวเลือกสำหรับการควบคุมการสร้างเนื้อหา

ข้อกำหนดเบื้องต้น

บทแนะนำนี้จะถือว่าคุณคุ้นเคยกับการสร้างแอปพลิเคชันด้วย Go

ในบทแนะนำนี้ โปรดตรวจสอบว่าสภาพแวดล้อมในการพัฒนาซอฟต์แวร์ของคุณเป็นไปตามข้อกำหนดต่อไปนี้

เริ่มเวอร์ชัน 1.20 ขึ้นไป

ตั้งค่าโปรเจ็กต์

ก่อนที่จะเรียกใช้ Gemini API คุณต้องตั้งค่าโปรเจ็กต์ ซึ่งรวมถึงการตั้งค่าคีย์ API การติดตั้งแพ็กเกจ SDK และการเริ่มต้นใช้งานโมเดล

ตั้งค่าคีย์ API

หากต้องการใช้ Gemini API คุณจะต้องมีคีย์ API หากยังไม่มี ให้ สร้างคีย์ใน Google AI Studio

รับคีย์ API

รักษาความปลอดภัยของคีย์ API

ขอแนะนำว่าอย่าตรวจสอบคีย์ API ในระบบควบคุมเวอร์ชัน คุณควรใช้ที่เก็บข้อมูลลับสำหรับคีย์ API แทน

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

ติดตั้งแพ็กเกจ SDK

หากต้องการใช้ Gemini API ในแอปพลิเคชันของคุณเอง คุณต้องgetแพ็กเกจ Go SDK ในไดเรกทอรีโมดูลดังนี้

go get github.com/google/generative-ai-go

เริ่มต้นโมเดล Generative

คุณต้องนำเข้าและเริ่มต้นโมเดล Generative ก่อนจึงจะทำการเรียก API ได้

import "github.com/google/generative-ai-go/genai"
import "google.golang.org/api/option"

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("MODEL_NAME")

เมื่อระบุโมเดล โปรดทราบข้อมูลต่อไปนี้

ใช้รูปแบบที่เหมาะกับ Use Case ของคุณโดยเฉพาะ (เช่น gemini-pro-vision สำหรับอินพุตหลายรูปแบบ) ในคู่มือนี้ วิธีการใช้รายการโมเดลที่แนะนำ สำหรับแต่ละกรณีการใช้งาน

หมายเหตุ: ดูข้อมูลโดยละเอียดเกี่ยวกับโมเดลที่พร้อมใช้งาน รวมถึงความสามารถและขีดจำกัดของอัตราได้ที่รุ่น Gemini ขีดจำกัดอัตราสำหรับรุ่น Gemini Pro คือ 60 คำขอต่อนาที (RPM) และเรามีตัวเลือกให้ขอเพิ่มขีดจำกัดอัตราคำขอ

ใช้ Use Case ที่พบบ่อย

เมื่อตั้งค่าโปรเจ็กต์แล้ว คุณจะสํารวจโดยใช้ Gemini API เพื่อนํากรณีการใช้งานต่างๆ ไปใช้ได้ ดังนี้

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

ในส่วน Use Case ขั้นสูง คุณจะเห็นข้อมูลเกี่ยวกับ Gemini API และการฝัง

สร้างข้อความจากการป้อนข้อความเท่านั้น

เมื่ออินพุตของพรอมต์มีเฉพาะข้อความ ให้ใช้โมเดล gemini-pro กับเมธอด GenerateContent เพื่อสร้างเอาต์พุตข้อความ

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-only input, use the gemini-pro model
model := client.GenerativeModel("gemini-pro")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

สร้างข้อความจากการป้อนข้อความและรูปภาพ (มัลติโมดัล)

Gemini มีโมเดลแบบหลายโมดัล (gemini-pro-vision) เพื่อให้คุณป้อนทั้งข้อความและรูปภาพ โปรดอ่านข้อกำหนดเกี่ยวกับรูปภาพสำหรับข้อความแจ้ง

เมื่ออินพุตของพรอมต์มีทั้งข้อความและรูปภาพ ให้ใช้โมเดล gemini-pro-vision กับเมธอด GenerateContent เพื่อสร้างเอาต์พุตข้อความ

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-and-image input (multimodal), use the gemini-pro-vision model
model := client.GenerativeModel("gemini-pro-vision")

imgData1, err := os.ReadFile(pathToImage1)
if err != nil {
  log.Fatal(err)
}

imgData2, err := os.ReadFile(pathToImage1)
if err != nil {
  log.Fatal(err)
}

prompt := []genai.Part{
  genai.ImageData("jpeg", imgData1),
  genai.ImageData("jpeg", imgData2),
  genai.Text("What's different between these two pictures?"),
}
resp, err := model.GenerateContent(ctx, prompt...)

if err != nil {
  log.Fatal(err)
}

สร้างการสนทนาแบบหลายมุมมอง (แชท)

การใช้ Gemini จะช่วยให้คุณสร้างการสนทนารูปแบบอิสระได้ในหลายๆ จุด SDK ช่วยลดความซับซ้อนของกระบวนการด้วยการจัดการสถานะของการสนทนา จึงต่างจาก GenerateContent ตรงที่คุณไม่ต้องจัดเก็บประวัติการสนทนาเอง

หากต้องการสร้างการสนทนาแบบมัลติเทิร์น (เช่น แชท) ให้ใช้โมเดล gemini-pro และเริ่มต้นแชทโดยเรียกใช้ StartChat() จากนั้นใช้ SendMessage() เพื่อส่ง ข้อความสำหรับผู้ใช้ใหม่ ซึ่งจะต่อท้ายข้อความและการตอบกลับประวัติการแชทด้วย

มี 2 ตัวเลือกที่เป็นไปได้สำหรับ role ที่เชื่อมโยงกับเนื้อหาในการสนทนา ดังนี้

user: บทบาทที่แสดงข้อความแจ้ง ค่านี้เป็นค่าเริ่มต้นสำหรับการเรียก SendMessage
model: บทบาทที่ระบุคำตอบ บทบาทนี้สามารถใช้เมื่อเรียกใช้ StartChat() ด้วย history ที่มีอยู่

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-only input, use the gemini-pro model
model := client.GenerativeModel("gemini-pro")
// Initialize the chat
cs := model.StartChat()
cs.History = []*genai.Content{
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Hello, I have 2 dogs in my house."),
    },
    Role: "user",
  },
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Great to meet you. What would you like to know?"),
    },
    Role: "model",
  },
}

resp, err := cs.SendMessage(ctx, genai.Text("How many paws are in my house?"))
if err != nil {
  log.Fatal(err)
}

ใช้สตรีมมิงเพื่อให้โต้ตอบได้เร็วขึ้น

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

ตัวอย่างต่อไปนี้แสดงวิธีการใช้สตรีมมิงด้วยเมธอด GenerateContentStream เพื่อสร้างข้อความจากข้อความแจ้งการป้อนข้อความและรูปภาพ

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-and-image input (multimodal), use the gemini-pro-vision model
model := client.GenerativeModel("gemini-pro-vision")

imageBytes, err := os.ReadFile(pathToImage)

img := genai.ImageData("jpeg", imageBytes)
prompt := genai.Text("Tell me a story about this animal")
iter := model.GenerateContentStream(ctx, img, prompt)

for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }

  // ... print resp
}

คุณสามารถใช้วิธีการที่คล้ายกันสำหรับการป้อนข้อความเท่านั้นและกรณีการใช้งานแชท

prompt := genai.Text("Tell me a story about a lumberjack and his giant ox")
iter := model.GenerateContentStream(ctx, prompt)

prompt := genai.Text("And how do you feel about that?")
iter := cs.SendMessageStream(ctx, prompt)

นำกรณีการใช้งานขั้นสูงไปใช้

กรณีการใช้งานทั่วไปที่อธิบายไว้ในส่วนก่อนหน้าของบทแนะนำนี้ช่วยให้คุณคุ้นเคยกับการใช้ Gemini API ได้ ส่วนนี้จะอธิบายกรณีการใช้งานที่อาจถือว่ามีขั้นสูงกว่า

ใช้การฝัง

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

ใช้รูปแบบ embedding-001 ด้วยเมธอด EmbedContent (หรือเมธอด BatchEmbedContent) เพื่อสร้างการฝัง ตัวอย่างต่อไปนี้จะสร้างการฝังสำหรับสตริงเดียว

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()
em := client.EmbeddingModel("embedding-001")
res, err := em.EmbedContent(ctx, genai.Text("The quick brown fox jumps over the lazy dog."))

if err != nil {
  panic(err)
}
fmt.Println(res.Embedding.Values)

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

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

นับโทเค็น

เมื่อใช้พรอมต์แบบยาว การนับโทเค็นก่อนที่จะส่งเนื้อหาไปยังโมเดลอาจเป็นประโยชน์ ตัวอย่างต่อไปนี้แสดงวิธีใช้ CountTokens() สำหรับ Use Case ต่างๆ

// For text-only input
text := "Parrots can be green and live a long time."
resp, err := model.CountTokens(ctx, genai.Text(text))
if err != nil {
  log.Fatal(err)
}
fmt.Println(resp.TotalTokens)

// For text-and-image input (multimodal)
text := "Parrots can be green and live a long time."
imageBytes, err := os.ReadFile(pathToImage)
if err != nil {
  log.Fatal(err)
}

resp, err := model.CountTokens(
    ctx,
    genai.Text(text),
    genai.ImageData("png", imageBytes))
  if err != nil {
    log.Fatal(err)
}
fmt.Println(resp.TotalTokens)

ตัวเลือกในการควบคุมการสร้างเนื้อหา

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

กำหนดค่าพารามิเตอร์โมเดล

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

// ...

model := client.GenerativeModel("MODEL_NAME")

// Configure model parameters by invoking Set* methods on the model.
model.SetTemperature(0.9)
model.SetTopK(1)

// ...

ใช้การตั้งค่าความปลอดภัย

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

วิธีตั้งค่าความปลอดภัย 1 รายการมีดังนี้

// ...

model := client.GenerativeModel("MODEL_NAME")

model.SafetySettings = []*genai.SafetySetting{
  {
    Category:  genai.HarmCategoryHarassment,
    Threshold: genai.HarmBlockOnlyHigh,
  },
}

// ...

คุณยังกำหนดการตั้งค่าความปลอดภัยได้มากกว่า 1 รายการดังนี้

// ...

model := client.GenerativeModel("MODEL_NAME")

model.SafetySettings = []*genai.SafetySetting{
  {
    Category:  genai.HarmCategoryHarassment,
    Threshold: genai.HarmBlockOnlyHigh,
  },
  {
    Category:  genai.HarmCategoryHateSpeech,
    Threshold: genai.HarmBlockMediumAndAbove,
  },
}

// ...

ขั้นตอนถัดไป

การออกแบบพรอมต์คือกระบวนการสร้างพรอมต์ที่กระตุ้นให้เกิดการตอบสนองที่ต้องการจากโมเดลภาษา การเขียนพรอมต์ที่มีโครงสร้างที่ดีเป็นส่วนสำคัญในการรับรองคำตอบที่ถูกต้องและมีคุณภาพสูงจากโมเดลภาษา ดูข้อมูลเกี่ยวกับแนวทางปฏิบัติแนะนำสำหรับการเขียนข้อความแจ้ง
Gemini มีโมเดลหลายรูปแบบเพื่อตอบสนองความต้องการในกรณีการใช้งานที่แตกต่างกัน เช่น ประเภทอินพุตและความซับซ้อน การใช้งานในแชทหรืองานภาษาในกล่องโต้ตอบอื่นๆ และข้อจำกัดด้านขนาด ดูข้อมูลเกี่ยวกับรุ่น Gemini ที่มี
Gemini มีตัวเลือกในการขอเพิ่มขีดจำกัดอัตราคำขอ ขีดจำกัดอัตราคำขอสำหรับรุ่น Gemini Pro คือ 60 คำขอต่อนาที (RPM)