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. Korzystając z modelu Gemini 1.5, możesz na przykład generować tekst na podstawie promptów zawierających tylko tekst lub multimodalnych. W tej sekcji znajdziesz podstawowe przykłady kodu. 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 1.5, aby wykonać zadanie związane z wizją. Dotyczy to na przykład dodawania podpisów do obrazu lub identyfikowania jego treści.
Poniższe przykłady kodu ilustrują 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 (zrzuty)
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 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.
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.
Poniższe przykłady kodu pokazują podstawową implementację promptu tekstowego dla każdego obsługiwanego języka:
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 (zrzuty)
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 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)
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ą 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 demonstracji czatu 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 wersji demonstracyjnej w samouczku 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 wersji demonstracyjnej 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 wersji demonstracyjnej w samouczku internetowym.
Rzutki (zrzuty)
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 demonstracji 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 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 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 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-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 (zrzuty)
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 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 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.
Aby uzyskać wyjściowy plik JSON dla modelu, ustaw opcję konfiguracji response_mime_type
na application/json
i podaj w prompcie format JSON, którego chcesz użyć 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 tekstowy opis schematu JSON, który chcesz zwrócić. Modele Gemini 1.5 Pro umożliwiają przekazywanie obiektu schematu (lub jego odpowiednika w języku Python), a dane wyjściowe modelu będą ściśle zgodne z tym schematem. Jest to też tzw. kontrolowane generowanie lub ograniczone dekodowanie.
Aby np. uzyskać listę obiektów Recipe
, przekaż list[Recipe]
do pola response_schema
w argumencie 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.
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
- Aby zacząć korzystać z interfejsu Google AI Studio, skorzystaj z krótkiego wprowadzenia do Google AI Studio.
- Wypróbuj interfejs Gemini API po stronie serwera dzięki samouczkom w językach Python, Go i Node.js.
- Zacznij tworzyć aplikacje internetowe z samouczkiem internetowym.
- Zacznij tworzyć aplikacje mobilne, korzystając z samouczka Swift lub samouczka na Androida.
- Jeśli korzystasz już z Google Cloud lub chcesz korzystać z Gemini w Vertex, aby wykorzystać zaawansowany ekosystem Google Cloud, zapoznaj się z generatywną AI w Vertex AI, aby dowiedzieć się więcej.