Google AI client SDK

באמצעות Google AI client SDK אפשר לבצע קריאה ל-Gemini API ולהשתמש במשפחת המודלים של Gemini ישירות מאפליקציית Android.

ברמה ללא תשלום אפשר להתנסות ללא עלות. פרטים נוספים על התמחור מופיעים במדריך התמחור.

הארכיטקטורה של שילוב ה-AI מבית Google
איור 1. ארכיטקטורת השילוב של Google AI.

תחילת העבודה

לפני שתבצעו אינטראקציה עם Gemini API ישירות מהאפליקציה, תצטרכו לבצע כמה פעולות, כולל היכרות עם הנחיות, יצירת מפתח API והגדרת האפליקציה לשימוש ב-SDK.

התנסות בהנחיות

מתחילים ביצירת אב טיפוס של ההנחיה ב-Google AI Studio.

Google AI Studio הוא סביבת פיתוח משולבת (IDE) לעיצוב הנחיות וליצירת אב טיפוס. אפשר להעלות קבצים כדי לבדוק הנחיות עם טקסט ותמונות, ולשמור הנחיה כדי לחזור אליה מאוחר יותר.

יצירת ההנחיה המתאימה לתרחיש לדוגמה היא יותר אמנות מאשר מדע, ולכן חשוב מאוד לבצע ניסויים. מידע נוסף על הנחיות זמין במסמכי התיעוד הרשמיים של Google AI.

Google AI Studio
איור 2. Google AI Studio

למידע נוסף על היכולות המתקדמות של Google AI Studio, קראו את המדריך למתחילים ב-Google AI Studio.

יצירת מפתח ה-API

כשההודעה נראית לכם טובה, לוחצים על Get API key כדי ליצור את מפתח ה-API של Gemini. המפתח יאוחסן באפליקציה, וזה בסדר לניסויים וליצירת אב טיפוס, אבל לא מומלץ לשימוש בסביבת ייצור.

בנוסף, כדי למנוע את ההתחייבות של מפתח ה-API למאגר של קוד המקור, צריך להשתמש בפלאגין gradle של Secrets.

מוסיפים את יחסי התלות של Gradle

מוסיפים לאפליקציה את התלות ב-Google AI client SDK:

Kotlin

dependencies {
  [...]
 implementation("com.google.ai.client.generativeai:generativeai:0.7.0")
}

Java

dependencies {
  [...]
  implementation("com.google.ai.client.generativeai:generativeai:0.7.0")

  // Required to use `ListenableFuture` from Guava Android for one-shot generation
  implementation("com.google.guava:guava:31.0.1-android")

  // Required to use `Publisher` from Reactive Streams for streaming operations
  implementation("org.reactivestreams:reactive-streams:1.0.4")
}

יצירת GenerativeModel

מתחילים ביצירת אובייקט GenerativeModel על ידי ציון הפרטים הבאים:

  • שם המודל: gemini-1.5-flash,‏ gemini-1.5-pro או gemini-1.0-pro
  • מפתח ה-API שנוצר באמצעות Google AI Studio.

אפשר להגדיר את פרמטרי המודל ולספק ערכים לטמפרטורה, ל-topK, ל-topP ולאסימוני הפלט המקסימליים.

אפשר גם להגדיר את תכונות הבטיחות לנושאים הבאים:

  • HARASSMENT
  • HATE_SPEECH
  • SEXUALLY_EXPLICIT
  • DANGEROUS_CONTENT

Kotlin

val model = GenerativeModel(
  model = "gemini-1.5-flash-001",
  apiKey = BuildConfig.apikey,
  generationConfig = generationConfig {
    temperature = 0.15f
    topK = 32
    topP = 1f
    maxOutputTokens = 4096
  },
  safetySettings = listOf(
    SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.DANGEROUS_CONTENT, BlockThreshold.MEDIUM_AND_ABOVE),
  )
)

Java

GenerationConfig.Builder configBuilder = new GenerationConfig.Builder();
configBuilder.temperature = 0.15f;
configBuilder.topK = 32;
configBuilder.topP = 1f;
configBuilder.maxOutputTokens = 4096;

ArrayList<SafetySetting> safetySettings = new ArrayList();
safetySettings.add(new SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.DANGEROUS_CONTENT, BlockThreshold.MEDIUM_AND_ABOVE));

GenerativeModel gm = new GenerativeModel(
    "gemini-1.5-flash-001",
    BuildConfig.apiKey,
    configBuilder.build(),
    safetySettings
);

שימוש ב-Google AI client SDK באפליקציה

עכשיו, אחרי שקיבלת מפתח API והגדרת את האפליקציה לשימוש ב-SDK, אפשר להתחיל לבצע פעולות ב-Gemini API.

יצירת טקסט

כדי ליצור תשובת טקסט, קוראים ל-generateContent() עם ההנחיה.

Kotlin

scope.launch {
  val response = model.generateContent("Write a story about a green robot.")
}

Java

// In Java, create a GenerativeModelFutures from the GenerativeModel.
// generateContent() returns a ListenableFuture.
// Learn more:
// https://developer.android.com/develop/background-work/background-tasks/asynchronous/listenablefuture

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Content content = new Content.Builder()
      .addText("Write a story about a green robot.")
      .build();
Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);

Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
      @Override
      public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
      }

      @Override
      public void onFailure(Throwable t) {
        t.printStackTrace();
      }
}, executor);

שימו לב ש-generateContent() היא פונקציית suspend, שמשתלבת היטב בקוד Kotlin קיים.

יצירת טקסט מתמונות וממדיה אחרת

אפשר גם ליצור טקסט מהנחיה שכוללת טקסט ותמונות או מדיה אחרת. כשקוראים ל-generateContent(), אפשר להעביר את המדיה כנתונים מוטמעים (כמו בדוגמה שבהמשך).

Kotlin

scope.launch {
  val response = model.generateContent(
    content {
      image(bitmap)
      text("What is the object in this picture?")
    }
  )
}

Java

Content content = new Content.Builder()
     .addImage(bitmap)
     .addText("What is the object in this picture?")
     .build();

Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);

Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
      @Override
      public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
      }

      @Override
      public void onFailure(Throwable t) {
        t.printStackTrace();
      }
}, executor);

שיחה עם זיכרון

אפשר גם לתמוך בשיחות עם כמה תורנים. מפעילים צ'אט באמצעות הפונקציה startChat(). אפשר גם לספק היסטוריית הודעות. לאחר מכן צריך להפעיל את הפונקציה sendMessage() כדי לשלוח הודעות בצ'אט.

Kotlin

val chat = model.startChat(
    history = listOf(
        content(role = "user") { text("Hello, I have 2 dogs in my house.") },
        content(role = "model") { text("Great to meet you. What would you like to know?") }
    )
)

scope.launch {
   val response = chat.sendMessage("How many paws are in my house?")
}

Java

Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

// (Optional) create message history
Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = userContentBuilder.build();

List<Content> history = Arrays.asList(userContent, modelContent);

// Initialize the chat
ChatFutures chat = model.startChat(history);

Content.Builder userMessageBuilder = new Content.Builder();
userMessageBuilder.setRole("user");
userMessageBuilder.addText("How many paws are in my house?");
Content userMessage = userMessageBuilder.build();

Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = chat.sendMessage(userMessage);

Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

שידור התשובה

כדי לקבל אינטראקציות מהירות יותר, אפשר לא להמתין לתוצאה המלאה של יצירת המודל, אלא להשתמש בסטרימינג כדי לטפל בתוצאות חלקיות. משתמשים ב-generateContentStream() כדי לשדר תשובה.

Kotlin

someScope.launch {
  var outputContent = ""
  
  generativeModel.generateContentStream(inputContent)
    .collect { response ->
      outputContent += response.text
    }
}

Java

// In Java, the method generateContentStream() returns a Publisher
// from the Reactive Streams library.
// https://www.reactive-streams.org/

Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

StringBuilder outputContent = new StringBuilder();

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
  @Override
  public void onNext(GenerateContentResponse generateContentResponse) {
    String chunk = generateContentResponse.getText();
    outputContent.append(chunk);
  }

    @Override
    public void onComplete() {
        // ...
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onSubscribe(Subscription s) {
       s.request(Long.MAX_VALUE);  // Request all messages
 }
});

Android Studio

ב-Android Studio יש כלים נוספים שיעזרו לכם להתחיל.

  • תבנית להתחלת השימוש ב-Gemini API: התבנית הזו עוזרת ליצור מפתח API ישירות מ-Android Studio, ויוצרת פרויקט שכולל את יחסי התלות הנדרשים ב-Android לשימוש בממשקי Gemini API.
  • דוגמה ל-AI גנרטיבי: הדוגמה הזו מאפשרת לייבא את ה-SDK של לקוח Google AI לאפליקציית הדוגמה ל-Android ב-Android Studio.

השלבים הבאים