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

บทแนะนำ: เริ่มต้นใช้งาน Gemini API

บทแนะนำนี้จะสาธิตวิธีเข้าถึง 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

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

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

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

เมื่อระบุโมเดล ให้คำนึงถึงสิ่งต่อไปนี้

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

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

ใช้ Use Case ทั่วไป

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

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

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

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

เมื่ออินพุตพรอมต์มีข้อความเท่านั้น ให้ใช้โมเดล Gemini 1.5 หรือโมเดล Gemini 1.0 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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

สร้างข้อความจากการป้อนข้อความและรูปภาพ (หลายรูปแบบ)

Gemini มีโมเดลต่างๆ ที่รองรับการป้อนข้อมูลหลายรูปแบบ (รุ่น Gemini 1.5 และ Gemini 1.0 Pro Vision) คุณจึงป้อนได้ทั้งข้อความและรูปภาพ โปรดอ่านข้อกำหนดเกี่ยวกับรูปภาพสำหรับพรอมต์

เมื่ออินพุตพรอมต์มีทั้งข้อความและรูปภาพ ให้ใช้โมเดล Gemini 1.5 หรือโมเดล Gemini 1.0 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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")

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 1.5 หรือโมเดล Gemini 1.0 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()

// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
model := client.GenerativeModel("gemini-1.5-flash")
// 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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")

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)

ใช้ Use Case ขั้นสูง

กรณีการใช้งานทั่วไปที่อธิบายในส่วนก่อนหน้าของบทแนะนำนี้ช่วยให้คุณคุ้นเคยกับการใช้ 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()
// For embeddings, use the embedding-001 model
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() สำหรับกรณีการใช้งานต่างๆ

// 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)

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

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

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

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

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

// ...

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

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

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

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

// ...

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

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

// ...

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

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