Omówienie interfejsu Gemini API

Gemini API zapewnia dostęp do najnowszych modeli generatywnych od Google. Gdy znasz już ogólne funkcje dostępne w interfejsie API, możesz rozpocząć programowanie w samouczku w wybranym języku.

Modele

Gemini to seria multimodalnych modeli generatywnej AI opracowanych przez Google. Modele Gemini mogą akceptować w promptach tekst i obrazy w zależności od wybranej wersji modelu oraz wyświetlać odpowiedzi tekstowe.

Bardziej szczegółowe informacje o modelach znajdziesz na stronie modeli Gemini. Możesz też użyć metody list_models, aby wyświetlić listę wszystkich dostępnych modeli, a potem użyć metody get_model, aby uzyskać metadane konkretnego modelu.

Dane i projektowanie promptów

Określone modele Gemini akceptują 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 musisz wziąć pod uwagę, w tym ogólny limit tokenów wejściowych w używanym modelu. Informacje o limitach tokenów w poszczególnych modelach znajdziesz w sekcji Modele Gemini.

Rozmiar promptów tworzonych przez interfejs Gemini API nie może przekraczać 20 MB. Interfejs Gemini API udostępnia interfejs File API do tymczasowego przechowywania plików multimedialnych na potrzeby promptów. Umożliwia on podawanie danych dotyczących promptów powyżej limitu 20 MB. Więcej informacji o korzystaniu z interfejsu Files API oraz o formatach plików, które obsługują prompty, znajdziesz w artykule Wysyłanie zapytań dotyczących plików multimedialnych.

Projekt promptu i wprowadzanie tekstu

Tworzenie skutecznych promptów, czyli inżynierii promptów, to połączenie sztuki i nauki. Wskazówki, jak korzystać z promptów, znajdziesz we wprowadzeniu do promptów, a w przewodniku po promptach poznasz różne podejścia.

Generuj treści

Interfejs Gemini API pozwala na wyświetlanie promptów zarówno z danymi tekstowymi, jak i graficznymi, w zależności od używanej wersji modelu. W modelu gemini-pro możesz na przykład generować tekst za pomocą promptów tekstowych, a do generowania promptów używać zarówno danych tekstowych, jak i graficznych.gemini-pro-vision W tej sekcji znajdziesz proste przykłady kodu każdego z nich. Bardziej szczegółowy przykład uwzględniający wszystkie parametry znajdziesz w dokumentacji interfejsu API generateContent.

Wprowadzanie tekstu i obrazu

Możesz wysłać prompt tekstowy z obrazem do modelu gemini-pro-vision, aby wykonać zadanie związane z wizją. Dotyczy to na przykład dodawania do obrazu podpisów lub identyfikowania jego zawartości.

Podane niżej przykłady kodu ilustrują prostą implementację promptu w postaci tekstu i obrazu w każdym obsługiwanym języku:

Python

model = genai.GenerativeModel('gemini-pro-vision')

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-pro-vision",
    content=[prompt, cookie_picture]
)
print(response.text)

Pełny fragment kodu znajdziesz w samouczku Pythona.

Go 

vmodel := client.GenerativeModel("gemini-pro-vision")

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-pro-vision" });

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.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro-vision" });

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 (zrzuty) 

final model = GenerativeModel(model: 'gemini-pro-vision', 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-pro-vision", 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-pro-vision",
    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 Androida.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro-vision: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.

Wprowadzanie tylko tekstu

Gemini API może też obsługiwać wprowadzanie danych tylko w formie tekstowej. Ta funkcja pozwala wykonywać zadania związane z przetwarzaniem języka naturalnego (NLP), takie jak uzupełnianie i podsumowywanie tekstu.

W poniższych przykładach kodu pokazano prostą implementację promptu tekstowego w przypadku każdego obsługiwanego języka:

Python

model = genai.GenerativeModel('gemini-pro-vision')

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

response = model.generate_content(prompt)

Pełny przykład znajdziesz w samouczku Pythona.

Go 

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-pro")
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-pro" });
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.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
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 (zrzuty) 

final model = GenerativeModel(model: 'gemini-pro', 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-pro", 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-pro",
    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 Androida.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro: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)

Interfejs Gemini API umożliwia tworzenie interaktywnych czatów dla użytkowników. Korzystanie z funkcji czatu w interfejsie API pozwala na gromadzenie wielu rund pytań i odpowiedzi, dzięki czemu użytkownicy mogą stopniowo podchodzić do odpowiedzi lub uzyskiwać pomoc w przypadku wieloczęściowych problemów. Ta funkcja jest idealna w przypadku aplikacji wymagających ciągłej komunikacji, takich jak czatboty, interaktywne nauczyciele czy asystenty obsługi klienta.

Poniższe przykłady kodu ilustrują prostą implementację interakcji z czatem w każdym obsługiwanym języku:

Python

  model = genai.GenerativeModel('gemini-pro')
  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 demonstracji czatu w samouczku Pythona.

Go 

model := client.GenerativeModel("gemini-pro")
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 wersji demonstracyjnej w samouczku Go.

Node.js

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

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 wersji demonstracyjnej w samouczku Node.js.

Web

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

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 wersji demonstracyjnej w samouczku internetowym.

Rzutki (zrzuty) 

final model = GenerativeModel(model: 'gemini-pro', 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 demonstracji czatu w samouczku Dart (Flutter).

Swift

let model = GenerativeModel(name: "gemini-pro", 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 samouczku Swift.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro",
    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 Androida.

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-pro: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 przesyłane strumieniowo

Interfejs Gemini API zapewnia dodatkowy sposób otrzymywania odpowiedzi z modeli generatywnej AI: w postaci strumienia danych. Odpowiedź przesyłana strumieniowo powoduje wysyłanie kolejnych fragmentów danych z powrotem do aplikacji w miarę ich generowania przez model. Ta funkcja pozwala szybko odpowiadać na prośby użytkowników, aby pokazywać postępy i sprawiać, że Twoje działania będą bardziej interaktywne.

Odpowiedzi przesyłane strumieniowo są opcją swobodnych promptów i czatów z modelami Gemini. W przykładach poniżej pokazujemy, jak zażądać odpowiedzi strumieniowanej w odpowiedzi na prompt dla każdego obsługiwanego języka:

Python

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

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

Pełny fragment kodu znajdziesz w samouczku Pythona.

Go 

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-pro")

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-pro" });
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.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
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 (zrzuty) 

final model = GenerativeModel(model: 'gemini-pro', 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-pro", 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-pro",
    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 Androida.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro: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 prompt może być zwracana w formacie uporządkowanych danych, zwłaszcza jeśli korzystasz z odpowiedzi do wypełniania interfejsów programowania. Interfejs Gemini API udostępnia parametr konfiguracji, który służy do wysyłania żądań odpowiedzi w formacie JSON.

Tej funkcji wyjściowej możesz używać, ustawiając opcję konfiguracji response_mime_type na application/json i umieszczając specyfikację formatu JSON w treści żądania. Poniższy przykładowy kod pokazuje, jak zażądać odpowiedzi JSON na prompt:

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro-latest:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{ "contents":[{
            "parts":[{"text": "List 5 popular cookie recipes using this JSON schema: \{ \"type\": \"object\", \"properties\": \{ \"recipe_name\": \{ \"type\": \"string\" \},\}\}"}] }],
          "generationConfig": {
            "response_mime_type": "application/json",
          } }'

Osadzone elementy

Usługa umieszczania w interfejsie Gemini API generuje najnowocześniejsze reprezentacje dla słów, wyrażeń i zdań. Uzyskane w ten sposób wektory dystrybucyjne mogą być wykorzystywane w zadaniach NLP, takich jak wyszukiwanie semantyczne, klasyfikacja tekstu czy grupowanie. W przewodniku po umieszczaniu dowiesz się, czym jest umieszczanie, a także znajdziesz w kluczowych przypadkach użycia usługi umieszczania, która pomoże Ci zacząć.

Dalsze kroki