Google AI client SDK

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

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

תחילת העבודה

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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() עם ההנחיה.

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

// 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(), אפשר להעביר את המדיה כנתונים מוטמעים (כמו בדוגמה שבהמשך).

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

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() כדי לשלוח הודעות בצ'אט.

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?")
}

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() כדי לשדר תשובה.

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

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

השלבים הבאים

• אפליקציה לדוגמה של Google AI client SDK ל-Android ב-GitHub.
• מידע נוסף על Google AI client SDK זמין במסמכי התיעוד הרשמיים של Google AI.