Generowanie tekstu za pomocą interfejsu Gemini API

Gemini API może generować dane wyjściowe w postaci tekstu, gdy jako dane wejściowe zostaną mu przekazane tekst, obrazy, filmy i dźwięk.

Z tego przewodnika dowiesz się, jak generować tekst za pomocą metod generateContent i streamGenerateContent. Więcej informacji o możliwościach Gemini w zakresie przetwarzania obrazu i dźwięku znajdziesz w instrukcjach dotyczących obrazu i dźwięku.

Zanim zaczniesz: skonfiguruj projekt i klucz interfejsu API

Zanim wywołasz interfejs Gemini API, musisz skonfigurować projekt i klucz interfejsu API.

Generowanie tekstu na podstawie danych wejściowych zawierających tylko tekst

Najprostszym sposobem generowania tekstu za pomocą interfejsu Gemini API jest przekazanie modelowi pojedynczego tekstu wejściowego, jak w tym przykładzie:

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
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());
text_generation.js

W tym przypadku prompt („Napisz opowiadanie o magicznym plecaku”) nie zawiera żadnych przykładów danych wyjściowych, instrukcji dotyczących systemu ani informacji o formatowaniu. Jest to podejście zero-shot. W niektórych przypadkach prompt jednokrotny lub kilkukrotny może generować wyniki lepiej dopasowane do oczekiwań użytkowników. W niektórych przypadkach warto też podać instrukcje systemu, aby pomóc modelowi zrozumieć zadanie lub przestrzegać określonych wytycznych.

Generowanie tekstu na podstawie tekstu i obrazu

Interfejs Gemini API obsługuje dane wejściowe multimodalne, które łączą tekst z plikami multimedialnymi. Poniższy przykład pokazuje, jak wygenerować tekst na podstawie tekstu i obrazu:

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

function fileToGenerativePart(path, mimeType) {
  return {
    inlineData: {
      data: Buffer.from(fs.readFileSync(path)).toString("base64"),
      mimeType,
    },
  };
}

const prompt = "Describe how this product might be manufactured.";
// Note: The only accepted mime types are some image types, image/*.
const imagePart = fileToGenerativePart(
  `${mediaPath}/jetpack.jpg`,
  "image/jpeg",
);

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

Podobnie jak w przypadku promptów tekstowych, prompty multimodalne mogą wykorzystywać różne podejścia i ulepszenia. W zależności od wyniku uzyskanego w tym przykładzie możesz dodać do promptu instrukcje lub bardziej szczegółowo opisać czynności. Więcej informacji znajdziesz w artykule Strategie dotyczące wyświetlania promptów.

Generowanie strumienia tekstowego

Domyślnie model zwraca odpowiedź po zakończeniu całego procesu generowania tekstu. Możesz uzyskać szybsze interakcje, nie czekając na cały wynik, a zamiast tego używając strumieniowego przesyłania częściowych wyników.

Poniższy przykład pokazuje, jak zaimplementować strumieniowanie za pomocą metody streamGenerateContent do generowania tekstu z promptu tekstowego.

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
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();
  process.stdout.write(chunkText);
}
text_generation.js

Tworzenie interaktywnego czatu

Za pomocą interfejsu Gemini API możesz tworzyć interaktywne czaty dla użytkowników. Korzystając z funkcji czatu interfejsu API, możesz zbierać pytania i odpowiedzi w wielu etapach, co pozwala użytkownikom stopniowo uzyskiwać odpowiedzi lub uzyskać pomoc w przypadku problemów wielowątkowych. Ta funkcja jest idealna do aplikacji, które wymagają ciągłej komunikacji, takich jak czatboty, interaktywne programy nauczania czy asystenci obsługi klienta.

Ten przykładowy kod pokazuje podstawową implementację czatu:

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: [{ text: "Hello" }],
    },
    {
      role: "model",
      parts: [{ text: "Great to meet you. What would you like to know?" }],
    },
  ],
});
let result = await chat.sendMessage("I have 2 dogs in my house.");
console.log(result.response.text());
result = await chat.sendMessage("How many paws are in my house?");
console.log(result.response.text());
chat.js

Włączanie strumieniowego przesyłania czatu

Możesz też prowadzić transmisję strumieniową z czatem, jak w tym przykładzie:

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: [{ text: "Hello" }],
    },
    {
      role: "model",
      parts: [{ text: "Great to meet you. What would you like to know?" }],
    },
  ],
});
let result = await chat.sendMessageStream("I have 2 dogs in my house.");
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}
result = await chat.sendMessageStream("How many paws are in my house?");
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}
chat.js

Konfigurowanie generowania tekstu

Każdy prompt wysyłany do modelu zawiera parametry, które określają, jak model wygeneruje odpowiedzi. Aby skonfigurować te parametry, możesz użyć GenerationConfig. Jeśli nie skonfigurujesz parametrów, model użyje opcji domyślnych, które mogą się różnić w zależności od modelu.

W tym przykładzie pokazujemy, jak skonfigurować kilka dostępnych opcji.

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({
  model: "gemini-1.5-flash",
  generationConfig: {
    candidateCount: 1,
    stopSequences: ["x"],
    maxOutputTokens: 20,
    temperature: 1.0,
  },
});

const result = await model.generateContent(
  "Tell me a story about a magic backpack.",
);
console.log(result.response.text());
model_configuration.js

candidateCount określa liczbę wygenerowanych odpowiedzi do zwrócenia. Obecnie wartość ta może być ustawiona tylko na 1. Jeśli nie jest ustawiona, przyjmuje domyślnie wartość 1.

stopSequences określa zbiór sekwencji znaków (do 5), które powodują zatrzymanie generowania danych wyjściowych. Jeśli zostanie podany, interfejs API zatrzyma się przy pierwszym wystąpieniu stop_sequence. Sekwencja zatrzymania nie będzie częścią odpowiedzi.

maxOutputTokens określa maksymalną liczbę tokenów, które mają być uwzględnione w kandydacie.

temperature określa losowość danych wyjściowych. Jeśli chcesz uzyskać więcej kreatywnych odpowiedzi, użyj wyższych wartości, a jeśli bardziej ścisłych – niższych. Wartości mogą się mieścić w zakresie [0,0, 2,0].

Możesz też skonfigurować poszczególne wywołania generateContent:

const result = await model.generateContent({
  contents: [
    {
      role: 'user',
      parts: [
        {
          text: prompt,
        }
      ],
    }
  ],
  generationConfig: {
    maxOutputTokens: 1000,
    temperature: 0.1,
  },
});
console.log(result.response.text());

Wartości ustawione w przypadku poszczególnych wywołań zastępują wartości w konstruktorze modelu.

Co dalej?

Teraz, gdy znasz już podstawy interfejsu Gemini API, możesz spróbować:

  • Interpretacja obrazu: dowiedz się, jak korzystać z natywnej interpretacji obrazu w Gemini do przetwarzania obrazów i filmów.
  • Instrukcje systemowe: instrukcje systemowe pozwalają kierować działaniem modelu na podstawie konkretnych potrzeb i przypadków użycia.
  • Rozumienie mowy: dowiedz się, jak używać natywnej funkcji Gemini do przetwarzania plików audio.