The Google AI Dart SDK is in public preview, which means its behavior and features could change in backward-incompatible ways. Preview releases should not be used in production.

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

เริ่มต้นใช้งาน Gemini API ในแอป Dart หรือ Flutter

ข้อควรระวัง: เราขอแนะนำให้ใช้ Google AI SDK สำหรับ Dart (Flutter) เพื่อเรียกใช้ Google AI Gemini API จากแอปของคุณโดยตรง เราขอแนะนำให้ใช้การสร้างต้นแบบเท่านั้น หากคุณมีแผนที่จะเปิดใช้การเรียกเก็บเงิน เราขอแนะนำอย่างยิ่งให้ใช้ 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

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

import 'package:google_generative_ai/google_generative_ai.dart';

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

final model = GenerativeModel(model: 'MODEL_NAME', apiKey: apiKey);

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

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

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

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

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

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

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

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

เมื่ออินพุตของพรอมต์มีเฉพาะข้อความ ให้ใช้โมเดล gemini-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);
  }
  // For text-only input, use the gemini-pro model
  final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
  final content = [Content.text('Write a story about a magic backpack.')];
  final response = await model.generateContent(content);
  print(response.text);
}

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

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

เมื่ออินพุตของพรอมต์มีทั้งข้อความและรูปภาพ ให้ใช้โมเดล gemini-pro-vision กับเมธอด 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);
  }
  // For text-and-image input (multimodal), use the gemini-pro-vision model
  final model = GenerativeModel(model: 'gemini-pro-vision', 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-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);
  }
  // For text-only input, use the gemini-pro model
  final model = GenerativeModel(
      model: 'gemini-pro',
      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);

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

กรณีการใช้งานทั่วไปที่อธิบายไว้ในส่วนก่อนหน้าของบทแนะนำนี้ช่วยให้คุณคุ้นเคยกับการใช้ 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() สำหรับ Use Case ต่างๆ

// 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(
  model: 'MODEL_NAME',
  apiKey: apiKey,
  generationConfig: generationConfig,
);

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

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

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

final safetySettings = [
  SafetySetting(HarmCategory.harassment, HarmBlockThreshold.high)
];
final model = GenerativeModel(
  model: 'MODEL_NAME',
  apiKey: apiKey,
  safetySettings: safetySettings,
);

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

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

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

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