Omówienie interfejsu Gemini API

Gemini API zapewnia dostęp do najnowszych modeli generatywnych Google. Po zapoznaniu się z ogólnymi funkcjami dostępnymi za pośrednictwem interfejsu API możesz skorzystać z samouczka dla wybranego języka i rozpocząć programowanie.

Modele

Gemini to seria multimodalnych modeli generatywnej AI opracowanych przez Google. W zależności od wybranej odmiany modelu Gemini modele Gemini mogą akceptować tekst i obraz w promptach oraz generować odpowiedzi tekstowe.

Więcej szczegółowych informacji o modelu znajdziesz na stronie Modele Gemini. Możesz też użyć metody list_models, aby wyświetlić listę wszystkich dostępnych modeli, a następnie metody get_model, aby uzyskać metadane konkretnego modelu.

Dane i projekt promptów

Określone modele Gemini akceptują jako dane wejściowe zarówno dane tekstowe, jak i pliki multimedialne. Stwarza to wiele dodatkowych możliwości generowania treści, analizowania danych i rozwiązywania problemów. Istnieją pewne ograniczenia i wymagania, które należy wziąć pod uwagę, m.in. ogólny limit tokenów wejściowych dla używanego modelu. Informacje o limitach tokenów dla poszczególnych modeli znajdziesz w artykule Modele Gemini.

Wielkość promptów korzystających z Gemini API nie może przekraczać 20 MB. Gemini API udostępnia interfejs File API do tymczasowego przechowywania plików multimedialnych na potrzeby promptów. Pozwala to na podawanie danych promptów powyżej limitu 20 MB. Więcej informacji o korzystaniu z interfejsu Files API i formatach plików obsługiwanych w przypadku promptów znajdziesz w artykule Wyświetlanie promptów przy użyciu plików multimedialnych.

Projekt promptu i wpisywanie tekstu

Tworzenie skutecznych promptów to połączenie sztuki i nauki. Wskazówki dotyczące korzystania z podpowiedzi znajdziesz we wprowadzeniu do promptów, a w przewodniku po promptach 101 znajdziesz różne sposoby ich wykorzystywania.

Generuj treści

W zależności od używanej odmiany modelu interfejs Gemini API pozwala używać w promptach zarówno danych tekstowych, jak i graficznych. Za pomocą modelu Gemini 1.5 możesz na przykład generować tekst na podstawie promptów tekstowych lub multimodalnych. W tej sekcji znajdziesz podstawowe przykłady kodu każdego z nich. Bardziej szczegółowy przykład, który obejmuje wszystkie parametry, znajdziesz w dokumentacji interfejsu API generateContent.

Pole do wprowadzania tekstu i obrazu

Do modelu Gemini 1.5 możesz wysłać prompt tekstowy z obrazem, aby wykonać zadanie związane z wizją. Może to być na przykład dodanie podpisu do obrazu lub wskazanie, że ktoś się na nim znajduje.

Poniższe przykłady kodu pokazują podstawową implementację promptu tekstowego i graficznego w każdym obsługiwanym języku:

Python

model = genai.GenerativeModel('gemini-1.5-flash')

cookie_picture = {
    'mime_type': 'image/png',
    'data': pathlib.Path('cookie.png').read_bytes()
}
prompt = "Do these look store-bought or homemade?"

response = model.generate_content(
    model="gemini-1.5-flash",
    content=[prompt, cookie_picture]
)
print(response.text)

Pełny fragment kodu znajdziesz w samouczku Pythona.

Przeczytaj 

vmodel := client.GenerativeModel("gemini-1.5-flash")

data, err := os.ReadFile(filepath.Join("path-to-image", imageFile))
if err != nil {
  log.Fatal(err)
}
resp, err := vmodel.GenerateContent(ctx, genai.Text("Do these look store-bought or homemade?"), genai.ImageData("jpeg", data))
if err != nil {
  log.Fatal(err)
}

Pełny przykład znajdziesz w samouczku Go.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const prompt = "Do these look store-bought or homemade?";
const image = {
  inlineData: {
    data: Buffer.from(fs.readFileSync("cookie.png")).toString("base64"),
    mimeType: "image/png",
  },
};

const result = await model.generateContent([prompt, image]);
console.log(result.response.text());

Pełny przykład znajdziesz w samouczku Node.js.

Internet

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const prompt = "Do these look store-bought or homemade?";
const image = {
  inlineData: {
    data: base64EncodedImage /* see JavaScript quickstart for details */,
    mimeType: "image/png",
  },
};

const result = await model.generateContent([prompt, image]);
console.log(result.response.text());

Pełny przykład znajdziesz w samouczku internetowym.

Rzutki (Flutter) 

final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
final prompt = 'Do these look store-bought or homemade?';
final imageBytes = await File('cookie.png').readAsBytes();
final content = [
  Content.multi([
    TextPart(prompt),
    DataPart('image/png', imageBytes),
  ])
];

final response = await model.generateContent(content);
print(response.text);

Pełny przykład znajdziesz w samouczku Dart (Flutter).

Swift

let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
let cookieImage = UIImage(...)
let prompt = "Do these look store-bought or homemade?"

let response = try await model.generateContent(prompt, cookieImage)

Pełny przykład znajdziesz w samouczku Swift.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey
)

val cookieImage: Bitmap = // ...
val inputContent = content() {
  image(cookieImage)
  text("Do these look store-bought or homemade?")
}

val response = generativeModel.generateContent(inputContent)
print(response.text)

Pełny przykład znajdziesz w samouczku na Androida.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-1.5-flash:generateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    -X POST \
    -d @<(echo'{
          "contents":[
            { "parts":[
                {"text": "Do these look store-bought or homemade?"},
                { "inlineData": {
                    "mimeType": "image/png",
                    "data": "'$(base64 -w0 cookie.png)'"
                  }
                }
              ]
            }
          ]
         }')

Więcej informacji znajdziesz w samouczku interfejsu API REST.

Pole tylko tekstowe

Interfejs Gemini API obsługuje również dane tekstowe. Ta funkcja umożliwia wykonywanie zadań związanych z przetwarzaniem języka naturalnego (NLP), takich jak uzupełnianie i podsumowywanie tekstu.

Poniższe przykłady kodu pokazują podstawową implementację promptu tekstowego w każdym obsługiwanym języku:

Python

model = genai.GenerativeModel('gemini-1.5-flash')

prompt = "Write a story about a magic backpack."

response = model.generate_content(prompt)

Pełny przykład znajdziesz w samouczku Pythona.

Przeczytaj 

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

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

Pełny przykład znajdziesz w samouczku Go.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContent(prompt);
console.log(result.response.text());

Pełny przykład znajdziesz w samouczku Node.js.

Internet

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContent(prompt);
console.log(result.response.text());

Pełny przykład znajdziesz w samouczku internetowym.

Rzutki (Flutter) 

final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = await model.generateContent(content);
print(response.text);

Pełny przykład znajdziesz w samouczku Dart (Flutter).

Swift

let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
let prompt = "Write a story about a magic backpack."

let response = try await model.generateContent(prompt)

Pełny przykład znajdziesz w samouczku Swift.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey
)

val prompt = "Write a story about a magic backpack."
val response = generativeModel.generateContent(prompt)
print(response.text)

Pełny przykład znajdziesz w samouczku na Androida.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-1.5-flash:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{ "contents":[
      { "parts":[{"text": "Write a story about a magic backpack"}]}
    ]
}'

Więcej informacji znajdziesz w samouczku interfejsu API REST.

Rozmowy wieloetapowe (czat)

Za pomocą interfejsu Gemini API możesz tworzyć interaktywne czaty dla użytkowników. Funkcja czatu w interfejsie API umożliwia zebranie wielu rund pytań i odpowiedzi, dzięki czemu użytkownicy mogą stopniowo szukać odpowiedzi lub uzyskać pomoc w rozwiązaniu wieloczęściowych problemów. Ta funkcja jest idealna w aplikacjach wymagających stałej komunikacji, takich jak czatboty, interaktywni korepetytorzy czy asystenci obsługi klienta.

Poniższe przykłady kodu pokazują podstawową implementację interakcji z czatem w przypadku każdego obsługiwanego języka:

Python

  model = genai.GenerativeModel('gemini-1.5-flash')
  chat = model.start_chat(history=[])

  response = chat.send_message(
      "Pretend you\'re a snowman and stay in character for each response.")
  print(response.text)

  response = chat.send_message(
      "What\'s your favorite season of the year?")
  print(response.text)

Pełny przykład znajdziesz w prezentacji, która znajduje się w samouczku Pythona.

Przeczytaj 

model := client.GenerativeModel("gemini-1.5-flash")
cs := model.StartChat()
cs.History = []*genai.Content{
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Pretend you're a snowman and stay in character for each response."),
    },
    Role: "user",
  },
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Hello! It's cold! Isn't that great?"),
    },
    Role: "model",
  },
}

resp, err := cs.SendMessage(ctx, genai.Text("What's your favorite season of the year?"))
if err != nil {
  log.Fatal(err)
}

Pełny przykład znajdziesz w prezentacji czatu w samouczku w Go.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash"});

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: "Pretend you're a snowman and stay in character for each response.",
    },
    {
      role: "model",
      parts: "Hello! It's cold! Isn't that great?",
    },
  ],
  generationConfig: {
    maxOutputTokens: 100,
  },
});

const msg = "What's your favorite season of the year?";
const result = await chat.sendMessage(msg);
console.log(result.response.text());

Pełny przykład znajdziesz w demonstracji czatu w samouczku Node.js.

Internet

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash"});

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: "Pretend you're a snowman and stay in character for each response.",
    },
    {
      role: "model",
      parts: "Hello! It's so cold! Isn't that great?",
    },
  ],
  generationConfig: {
    maxOutputTokens: 100,
  },
});

const msg = "What's your favorite season of the year?";
const result = await chat.sendMessage(msg);
console.log(result.response.text());

Pełny przykład znajdziesz w samouczku internetowym na czacie.

Rzutki (Flutter) 

final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
final chat = model.startChat(history: [
  Content.text(
      "Pretend you're a snowman and stay in character for each response."),
  Content.model([TextPart("Hello! It's cold! Isn't that great?")]),
]);
final content = Content.text("What's your favorite season of the year?");
final response = await chat.sendMessage(content);
print(response.text);

Pełny przykład znajdziesz w prezentacji czatu w samouczku Dart (Flutter).

Swift

let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
let chat = model.startChat()

var message = "Pretend you're a snowman and stay in character for each response."
var response = try await chat.sendMessage(message)

message = "What\'s your favorite season of the year?"
response = try await chat.sendMessage(message)

Pełny przykład znajdziesz w demonstracji czatu w samouczku Swift.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey
)

val chat = generativeModel.startChat()
val response = chat.sendMessage("Pretend you're a snowman and stay in
        character for each response.")
print(response.text)

Pełny przykład znajdziesz w samouczku na Androida.

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {"role":"user",
         "parts":[{
           "text": "Pretend you're a snowman and stay in character for each
        {"role": "model",
            response."}]},
         "parts":[{
           "text": "Hello! It's so cold! Isn't that great?"}]},
        {"role": "user",
         "parts":[{
           "text": "What\'s your favorite season of the year?"}]},
       ]
    }' 2> /dev/null | grep "text"
# response example:
"text": "Winter, of course!"

Więcej informacji znajdziesz w samouczku interfejsu API REST.

Odpowiedzi na bieżąco

Gemini API to dodatkowy sposób otrzymywania odpowiedzi z modeli generatywnej AI: w postaci strumienia danych. Odpowiedź strumieniowana wysyła przyrostowe fragmenty danych z powrotem do aplikacji w miarę ich generowania przez model. Ta funkcja pozwala szybko odpowiadać na prośbę użytkownika, aby pokazywać swoje postępy i tworzyć bardziej interaktywne środowisko.

Odpowiedzi strumieniowane to opcja w przypadku dowolnych promptów i czatów z modelami Gemini. Poniższe przykłady kodu pokazują, jak zażądać strumieniowej odpowiedzi na prompt w każdym obsługiwanym języku:

Python

prompt = "Write a story about a magic backpack."

response = genai.stream_generate_content(
    model="models/gemini-1.5-flash",
    prompt=prompt
)

Pełny fragment kodu znajdziesz w samouczku Pythona.

Przeczytaj 

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-1.5-flash")

iter := model.GenerateContentStream(ctx, genai.Text("Write a story about a magic backpack."))
for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }

  // print resp
}

Pełny przykład znajdziesz w samouczku Go.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream([prompt]);
// print text as it comes in
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
}

Pełny przykład znajdziesz w samouczku Node.js.

Internet

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream([prompt]);
// print text as it comes in
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
}

Pełny przykład znajdziesz w samouczku internetowym.

Rzutki (Flutter) 

final model = GenerativeModel(model: 'gemini-1.5-flash', apiKey: apiKey);
final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = model.generateContentStream(content);
await for (final chunk in response) {
  print(chunk.text);
}

Pełny przykład znajdziesz w samouczku Dart (Flutter).

Swift

let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: "API_KEY")
let prompt = "Write a story about a magic backpack."

let stream = model.generateContentStream(prompt)
for try await chunk in stream {
  print(chunk.text ?? "No content")
}

Pełny przykład znajdziesz w samouczku Swift.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey
)

val inputContent = content {
  text("Write a story about a magic backpack.")
}

var fullResponse = ""
generativeModel.generateContentStream(inputContent).collect { chunk ->
  print(chunk.text)
  fullResponse += chunk.text
}

Pełny przykład znajdziesz w samouczku na Androida.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-1.5-flash:streamGenerateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    --no-buffer \
    -d '{ "contents":[
            {"role": "user",
              "parts":[{"text": "Write a story about a magic backpack."}]
            }
          ]
        }' > response.json

Więcej informacji znajdziesz w samouczku interfejsu API REST.

Odpowiedzi w formacie JSON

W zależności od aplikacji odpowiedź na prompty może być zwracana w formacie uporządkowanych danych, zwłaszcza jeśli korzystasz z nich do wypełniania interfejsów programowania. Interfejs Gemini API udostępnia parametr konfiguracji umożliwiający żądanie odpowiedzi w formacie JSON.

Aby model wyjściowy mógł otrzymać plik JSON, ustaw opcję konfiguracji response_mime_type na application/json i podaj w prompcie format JSON, jaki chcesz uzyskać w odpowiedzi:

Python

model = genai.GenerativeModel('gemini-1.5-flash',
                              generation_config={"response_mime_type": "application/json"})

prompt = """
  List 5 popular cookie recipes.

  Using this JSON schema:

    Recipe = {"recipe_name": str}

  Return a `list[Recipe]`
  """

response = model.generate_content(prompt)
print(response.text)

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {
          "parts": [
            {
              "text": "\nList 5 popular cookie recipes.\n\nUsing this JSON schema:\n\n  Recipe = {\"recipe_name\": str}\n\nReturn a `list[Recipe]`\n      "
            }
          ]
        }
      ]
      "generationConfig": {
            "response_mime_type": "application/json",
      }
    }'

Modele Gemini 1.5 Flash akceptują tylko opis tekstowy schematu JSON, który chcesz zwrócić. Modele Gemini 1.5 Pro umożliwiają przekazanie obiektu schematu (lub jego odpowiednika w Pythonie), a dane wyjściowe modelu będą ściśle zgodne z tym schematem. Jest to tzw. kontrolowane generowanie lub ograniczone dekodowanie.

Aby na przykład uzyskać listę obiektów Recipe, przekaż list[Recipe] do pola response_schema argumentu generation_config:

Python

import typing_extensions as typing

class Recipe(typing.TypedDict):
  recipe_name: str

model = genai.GenerativeModel(model_name="models/gemini-1.5-pro")

result = model.generate_content(
  "List 5 popular cookie recipes",
  generation_config=genai.GenerationConfig(response_mime_type="application/json",
                                           response_schema = list[Recipe]))

print(result.text)

cURL

  curl https://generativelanguage.googleapis.com/v1beta/models/models/gemini-1.5-pro:generateContent?
      -H 'Content-Type: application/json'
      -X POST \
      -d '{
        "contents": [
          {
            "parts": [
              {
                "text": "List 5 popular cookie recipes"
              }
            ]
          }
        ],
        "generationConfig": {
          "responseMimeType": "application/json",
          "responseSchema": {
            "type": "ARRAY",
            "items": {
              "type": "OBJECT",
              "properties": {
                "recipe_name": {
                  "type": "STRING"
                }
              }
            }
          }
        }
      }'
  ```

Więcej informacji znajdziesz w krótkim wprowadzeniu do trybu JSON w książce kucharskiej Gemini API.

Wektory dystrybucyjne

Usługa umieszczania w interfejsie Gemini API generuje najnowocześniejsze wektory dystrybucyjne dla słów, wyrażeń i zdań. Uzyskane wektory dystrybucyjne mogą być następnie wykorzystywane do zadań NLP, takich jak wyszukiwanie semantyczne, klasyfikacja tekstu czy grupowanie. Zapoznaj się z przewodnikiem umieszczania, aby dowiedzieć się, czym są wektory dystrybucyjne i jakie są ich kluczowe zastosowania, aby łatwiej rozpocząć korzystanie z tej usługi.

Dalsze kroki