Gemini 1.5 Pro 2M หน้าต่างบริบท ความสามารถในการรันโค้ด และ Gemma 2 พร้อมใช้งานแล้ว ดูข้อมูลเพิ่มเติม

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

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

ข้อควรระวัง: ขอแนะนำให้ใช้ Google AI SDK สำหรับ Dart (Flutter) ในการเรียกใช้ Google AI API จากแอปของคุณโดยตรงสำหรับการสร้างต้นแบบเท่านั้น สำหรับ Use Case ที่ไม่ใช่การสร้างต้นแบบ เราขอแนะนำเป็นอย่างยิ่งให้ใช้ SDK เพื่อเรียกใช้เฉพาะฝั่งเซิร์ฟเวอร์ของ Google AI Gemini API เพื่อให้คีย์ API ของคุณปลอดภัย หากคุณฝังคีย์ API ลงในแอปบนอุปกรณ์เคลื่อนที่หรือเว็บแอปโดยตรง หรือดึงข้อมูลคีย์ดังกล่าวจากระยะไกลขณะรันไทม์ ก็อาจเสี่ยงให้ผู้ไม่ประสงค์ดีเข้าถึงคีย์ API ได้

บทแนะนำนี้อธิบายวิธีเข้าถึง Gemini API สำหรับแอปพลิเคชัน Dart หรือ Flutter โดยใช้ Google AI Dart SDK คุณใช้ SDK นี้ได้หากไม่ต้องการทำงานกับ REST API โดยตรงสำหรับการเข้าถึงโมเดล Gemini ในแอปของคุณ

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

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

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

สิ่งที่ต้องดำเนินการก่อน

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

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

Dart 3.2.0 ขึ้นไป

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

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

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

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

รับคีย์ API

รักษาคีย์ API ให้ปลอดภัย

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

ข้อมูลโค้ดทั้งหมดในบทแนะนำนี้จะถือว่าคุณเข้าถึงคีย์ API เป็นตัวแปรสภาพแวดล้อมกระบวนการ หากคุณกำลังพัฒนาแอป Flutter คุณจะใช้ String.fromEnvironment และส่ง --dart-define=API_KEY=$API_KEY ไปยัง flutter build หรือ flutter run เพื่อคอมไพล์ด้วยคีย์ API ได้เนื่องจากสภาพแวดล้อมของกระบวนการจะแตกต่างออกไปเมื่อเรียกใช้แอป

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

หากต้องการใช้ Gemini API ในแอปพลิเคชันของคุณเอง คุณจะต้องaddแพ็กเกจ google_generative_ai ไปยังแอป Dart หรือ Flutter ของคุณ โดยทำดังนี้

Dart

dart pub add google_generative_ai

Flutter

flutter pub add google_generative_ai

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

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

import 'dart:io';
import 'package:google_generative_ai/google_generative_ai.dart';

void main() async {

  // Access your API key as an environment variable (see "Set up your API key" above)
  final apiKey = Platform.environment['API_KEY'];
  if (apiKey == null) {
    print('No \$API_KEY environment variable');
    exit(1);
  }

  // The Gemini 1.5 models are versatile and work with most use cases
  final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
}

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

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

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

ใช้ Use Case ทั่วไป

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

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

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

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

เมื่ออินพุตพรอมต์มีข้อความเท่านั้น ให้ใช้โมเดล Gemini 1.5 หรือโมเดล Gemini 1.0 Pro ที่มี generateContent เพื่อสร้างเอาต์พุตข้อความ ดังนี้

import 'dart:io';

import 'package:google_generative_ai/google_generative_ai.dart';

void main() async {
  // Access your API key as an environment variable (see "Set up your API key" above)
  final apiKey = Platform.environment['API_KEY'];
  if (apiKey == null) {
    print('No \$API_KEY environment variable');
    exit(1);
  }
  // The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
  final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
  final content = [Content.text('Write a story about a magic backpack.')];
  final response = await model.generateContent(content);
  print(response.text);
}

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

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

เมื่ออินพุตพรอมต์มีทั้งข้อความและรูปภาพ ให้ใช้โมเดล Gemini 1.5 ที่มีเมธอด generateContent เพื่อสร้างเอาต์พุตข้อความ ดังนี้

import 'dart:io';

import 'package:google_generative_ai/google_generative_ai.dart';

void main() async {
  // Access your API key as an environment variable (see "Set up your API key" above)
  final apiKey = Platform.environment['API_KEY'];
  if (apiKey == null) {
    print('No \$API_KEY environment variable');
    exit(1);
  }
  // The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
  final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
  final (firstImage, secondImage) = await (
    File('image0.jpg').readAsBytes(),
    File('image1.jpg').readAsBytes()
  ).wait;
  final prompt = TextPart("What's different between these pictures?");
  final imageParts = [
    DataPart('image/jpeg', firstImage),
    DataPart('image/jpeg', secondImage),
  ];
  final response = await model.generateContent([
    Content.multi([prompt, ...imageParts])
  ]);
  print(response.text);
}

สร้างการสนทนาแบบผลัดกันเล่น (แชท)

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

หากต้องการสร้างการสนทนาแบบหลายเลี้ยว (เช่น แชท) ให้ใช้โมเดล Gemini 1.5 หรือโมเดล Gemini 1.0 Pro แล้วเริ่มแชทโดยโทรหา startChat() จากนั้นใช้ sendMessage() เพื่อส่งข้อความของผู้ใช้ใหม่ ซึ่งจะต่อท้ายข้อความและคำตอบในประวัติการแชทด้วย

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

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

import 'dart:io';

import 'package:google_generative_ai/google_generative_ai.dart';

Future<void> main() async {
  // Access your API key as an environment variable (see "Set up your API key" above)
  final apiKey = Platform.environment['API_KEY'];
  if (apiKey == null) {
    print('No \$API_KEY environment variable');
    exit(1);
  }
  // The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
  final model = GenerativeModel(
      model: 'gemini-1.5-flash',
      apiKey: apiKey,
      generationConfig: GenerationConfig(maxOutputTokens: 100));
  // Initialize the chat
  final chat = model.startChat(history: [
    Content.text('Hello, I have 2 dogs in my house.'),
    Content.model([TextPart('Great to meet you. What would you like to know?')])
  ]);
  var content = Content.text('How many paws are in my house?');
  var response = await chat.sendMessage(content);
  print(response.text);
}

ใช้สตรีมมิงเพื่อการโต้ตอบที่เร็วขึ้น

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

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

// ...

final response = model.generateContentStream([
  Content.multi([prompt, ...imageParts])
]);
await for (final chunk in response) {
  print(chunk.text);
}

// ...

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

// Use streaming with text-only input
final response = model.generateContentStream(content);

// Use streaming with multi-turn conversations (like chat)
final response = chat.sendMessageStream(content);

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

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

กำลังเรียกฟังก์ชัน

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

ใช้การฝัง

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

ใช้โมเดล embedding-001 กับเมธอด embedContent (หรือเมธอด batchEmbedContent) เพื่อสร้างการฝัง ตัวอย่างต่อไปนี้สร้างการฝังสำหรับสตริงเดียว

final model = GenerativeModel(model: 'embedding-001', apiKey: apiKey);
final content = Content.text('The quick brown fox jumps over the lazy dog.');
final result = await model.embedContent(content);
print(result.embedding.values);

นับโทเค็น

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

// For text-only input
final tokenCount = await model.countTokens(Content.text(prompt));
print('Token count: ${tokenCount.totalTokens}');

// For text-and-image input (multimodal)
final tokenCount = await model.countTokens([
  Content.multi([prompt, ...imageParts])
]);
print('Token count: ${tokenCount.totalTokens}');

// For multi-turn conversations (like chat)
final prompt = Content.text(message);
final allContent = [...chat.history, prompt];
final tokenCount = await model.countTokens(allContent);
print('Token count: ${tokenCount.totalTokens}');

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

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

โปรดทราบว่าการส่ง generationConfig หรือ safetySettings ไปยังเมธอดคำขอโมเดล (เช่น generateContent) จะลบล้างออบเจ็กต์การกำหนดค่าที่มีชื่อเดียวกันที่ส่งใน getGenerativeModel โดยสมบูรณ์

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

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

final generationConfig = GenerationConfig(
  stopSequences: ["red"],
  maxOutputTokens: 200,
  temperature: 0.9,
  topP: 0.1,
  topK: 16,
);
final model = GenerativeModel(
  // The Gemini 1.5 models are versatile and work with most use cases
  model: 'gemini-1.5-flash',
  apiKey: apiKey,
  generationConfig: generationConfig,
);

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

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

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

final safetySettings = [
  SafetySetting(HarmCategory.harassment, HarmBlockThreshold.high)
];
final model = GenerativeModel(
  // The Gemini 1.5 models are versatile and work with most use cases
  model: 'gemini-1.5-flash',
  apiKey: apiKey,
  safetySettings: safetySettings,
);

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

final safetySettings = [
  SafetySetting(HarmCategory.harassment, HarmBlockThreshold.high),
  SafetySetting(HarmCategory.hateSpeech, HarmBlockThreshold.high),
];

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

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