Pierwsze kroki z interfejsem Gemini API w aplikacjach Node.js

W tym samouczku pokazujemy, jak uzyskać dostęp do interfejsu Gemini API na potrzeby aplikacji Node.js za pomocą pakietu Google AI JavaScript SDK.

Z tego samouczka dowiesz się, jak:

Ten samouczek zawiera też sekcje dotyczące zaawansowanych przypadków użycia (takich jak umieszczanie na stronie i tokeny zliczania) oraz opcje kontrolowania generowania treści.

Wymagania wstępne

W tym samouczku zakładamy, że umiesz tworzyć aplikacje przy użyciu Node.js.

Aby ukończyć ten samouczek, sprawdź, czy Twoje środowisko programistyczne spełnia te wymagania:

  • Node.js w wersji 18 lub nowszej
  • npm

Konfigurowanie projektu

Zanim wywołasz interfejs Gemini API, musisz skonfigurować projekt, który obejmuje skonfigurowanie klucza interfejsu API, zainstalowanie pakietu SDK i zainicjowanie modelu.

Konfigurowanie klucza interfejsu API

Aby korzystać z interfejsu Gemini API, potrzebujesz klucza interfejsu API. Jeśli nie masz jeszcze klucza, utwórz go w Google AI Studio.

Uzyskiwanie klucza interfejsu API

Zabezpieczanie klucza interfejsu API

Zdecydowanie zalecamy, aby nie sprawdzać klucza interfejsu API w systemie kontroli wersji. Zamiast tego używaj magazynu obiektów tajnych klucza interfejsu API.

Wszystkie fragmenty kodu w tym samouczku zakładają, że uzyskujesz dostęp do klucza interfejsu API jako zmiennej środowiskowej.

Zainstaluj pakiet SDK

Aby używać interfejsu Gemini API we własnej aplikacji, musisz zainstalować pakiet GoogleGenerativeAI dla Node.js:

npm install @google/generative-ai

Inicjowanie modelu generatywnego

Zanim zaczniesz wywoływać interfejs API, musisz zaimportować i zainicjować model generatywny.

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

// ...

const model = genAI.getGenerativeModel({ model: "MODEL_NAME"});

// ...

Określając model, pamiętaj o tych kwestiach:

  • Użyj modelu, który odpowiada Twojemu przypadkowi użycia (np. gemini-pro-vision jest używany w przypadku multimodalnych danych wejściowych). W tym przewodniku w instrukcjach dotyczących poszczególnych implementacji wymieniono model zalecany dla każdego przypadku użycia.

Wdrażanie typowych przypadków użycia

Po skonfigurowaniu projektu możesz zacząć korzystać z interfejsu Gemini API, aby wdrażać różne przypadki użycia:

W sekcji zaawansowanych przypadków użycia znajdziesz informacje o interfejsie Gemini API i umieszczaniu.

Generuj tekst na podstawie samego tekstu

Jeśli dane wejściowe promptu zawierają tylko tekst, użyj modelu gemini-pro z metodą generateContent, aby wygenerować dane wyjściowe tekstowe:

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

async function run() {
  // For text-only input, use the gemini-pro model
  const model = genAI.getGenerativeModel({ model: "gemini-pro"});

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

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

run();

Generuj tekst na podstawie danych wejściowych typu tekst i obraz (multimodalne)

Gemini udostępnia model multimodalny (gemini-pro-vision), który umożliwia wpisywanie zarówno tekstu, jak i obrazów. Zapoznaj się z wymaganiami dotyczącymi obrazów w promptach.

Jeśli dane wejściowe promptu zawierają zarówno tekst, jak i obrazy, do wygenerowania danych wyjściowych tekstowych użyj modelu gemini-pro-vision z metodą generateContent:

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

// Converts local file information to a GoogleGenerativeAI.Part object.
function fileToGenerativePart(path, mimeType) {
  return {
    inlineData: {
      data: Buffer.from(fs.readFileSync(path)).toString("base64"),
      mimeType
    },
  };
}

async function run() {
  // For text-and-image input (multimodal), use the gemini-pro-vision model
  const model = genAI.getGenerativeModel({ model: "gemini-pro-vision" });

  const prompt = "What's different between these pictures?";

  const imageParts = [
    fileToGenerativePart("image1.png", "image/png"),
    fileToGenerativePart("image2.jpeg", "image/jpeg"),
  ];

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

run();

Tworzenie rozmów wieloetapowych (czat)

Dzięki Gemini możesz swobodnie prowadzić rozmowy w wielu etapach. Pakiet SDK upraszcza ten proces, zarządzając stanem rozmowy, więc w przeciwieństwie do pakietu generateContent nie musisz samodzielnie przechowywać historii rozmowy.

Aby utworzyć rozmowę wieloetapową (taką jak czat), użyj modelu gemini-pro i zainicjuj czat, wywołując metodę startChat(). Następnie za pomocą polecenia sendMessage() możesz wysłać nową wiadomość do użytkownika, która również dołączy tę wiadomość i odpowiedź do historii czatu.

Atrybut role może być powiązany z treścią rozmowy na 2 sposoby:

  • user: rola, która udostępnia prompty. Jest to wartość domyślna w przypadku wywołań funkcji sendMessage.

  • model: rola, która udziela odpowiedzi. Tej roli można używać przy wywoływaniu funkcji startChat() za pomocą istniejącej funkcji history.

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

async function run() {
  // For text-only input, use the gemini-pro model
  const model = genAI.getGenerativeModel({ model: "gemini-pro"});

  const chat = model.startChat({
    history: [
      {
        role: "user",
        parts: [{ text: "Hello, I have 2 dogs in my house." }],
      },
      {
        role: "model",
        parts: [{ text: "Great to meet you. What would you like to know?" }],
      },
    ],
    generationConfig: {
      maxOutputTokens: 100,
    },
  });

  const msg = "How many paws are in my house?";

  const result = await chat.sendMessage(msg);
  const response = await result.response;
  const text = response.text();
  console.log(text);
}

run();

Strumieniowanie zapewnia szybsze interakcje

Domyślnie model zwraca odpowiedź po zakończeniu całego procesu generowania. Możesz przyspieszyć interakcje, nie czekając na cały wynik. Zamiast tego możesz używać strumieniowania do obsługi częściowych wyników.

Z przykładu poniżej dowiesz się, jak wdrożyć strumieniowanie za pomocą metody generateContentStream, aby generować tekst na podstawie promptu z tekstem i obrazem.

//...

const result = await model.generateContentStream([prompt, ...imageParts]);

let text = '';
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
  text += chunkText;
}

//...

Podobne podejście możesz zastosować w przypadkach użycia związanych tylko z tekstem i na czacie.

// Use streaming with text-only input
const result = await model.generateContentStream(prompt);

Informacje o tym, jak utworzyć instancję chat, znajdziesz w przykładzie czatu powyżej.

// Use streaming with multi-turn conversations (like chat)
const result = await chat.sendMessageStream(msg);

Wdrażanie zaawansowanych przypadków użycia

Typowe przypadki użycia opisane w poprzedniej części tego samouczka pomogą Ci zapoznać się z interfejsem Gemini API. W tej sekcji opisujemy kilka przypadków użycia, które mogą być bardziej zaawansowane.

Użyj wektorów dystrybucyjnych

Umieszczanie to technika używana do przedstawiania informacji w postaci listy liczb zmiennoprzecinkowych w tablicy. Gemini możesz reprezentować tekst (słowa, zdania i bloki tekstu) w formie wektorowej, co ułatwia porównywanie i różnicowanie reprezentacji właściwościowych. Na przykład 2 teksty o podobnej tematyce lub uczuciach powinny mieć podobne osadzenia, co można zidentyfikować za pomocą matematycznych technik porównywania, takich jak podobieństwo cosinusowe.

Do generowania wektorów dystrybucyjnych użyj modelu embedding-001 z metodą embedContent (lub metody batchEmbedContent). Ten przykład generuje umieszczenie pojedynczego ciągu znaków:

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

async function run() {
  // For embeddings, use the embedding-001 model
  const model = genAI.getGenerativeModel({ model: "embedding-001"});

  const text = "The quick brown fox jumps over the lazy dog."

  const result = await model.embedContent(text);
  const embedding = result.embedding;
  console.log(embedding.values);
}

run();

Policz tokeny

W przypadku używania długich promptów warto zliczać tokeny przed wysłaniem jakiejkolwiek treści do modelu. Poniższe przykłady pokazują, jak używać właściwości countTokens() w różnych przypadkach użycia:

// For text-only input
const { totalTokens } = await model.countTokens(prompt);

// For text-and-image input (multimodal)
const { totalTokens } = await model.countTokens([prompt, ...imageParts]);

// For multi-turn conversations (like chat)
const history = await chat.getHistory();
const msgContent = { role: "user", parts: [{ text: msg }] };
const contents = [...history, msgContent];
const { totalTokens } = await model.countTokens({ contents });

Opcje sterowania generowaniem treści

Możesz kontrolować generowanie treści, konfigurując parametry modelu i używając ustawień bezpieczeństwa.

Pamiętaj, że przekazanie metody generationConfig lub safetySettings do metody żądania modelu (takiej jak generateContent) spowoduje pełne zastąpienie obiektu konfiguracji tą samą nazwą, która jest przekazywana w getGenerativeModel.

Skonfiguruj parametry modelu

Każdy prompt, który wysyłasz do modelu, zawiera wartości parametrów, które kontrolują sposób generowania odpowiedzi przez model. Model może generować różne wyniki dla różnych wartości parametrów. Dowiedz się więcej o parametrach modelu.

const generationConfig = {
  stopSequences: ["red"],
  maxOutputTokens: 200,
  temperature: 0.9,
  topP: 0.1,
  topK: 16,
};

const model = genAI.getGenerativeModel({ model: "MODEL_NAME",  generationConfig });

Korzystanie z ustawień bezpieczeństwa

Za pomocą ustawień bezpieczeństwa możesz dostosować prawdopodobieństwo otrzymania odpowiedzi, które mogą zostać uznane za szkodliwe. Ustawienia bezpieczeństwa domyślnie blokują treści o średnim lub wysokim prawdopodobieństwie, że mogą być niebezpieczne we wszystkich wymiarach. Dowiedz się więcej o ustawieniach bezpieczeństwa.

Aby skonfigurować jedno ustawienie bezpieczeństwa:

import { HarmBlockThreshold, HarmCategory } from "@google/generative-ai";

// ...

const safetySettings = [
  {
    category: HarmCategory.HARM_CATEGORY_HARASSMENT,
    threshold: HarmBlockThreshold.BLOCK_ONLY_HIGH,
  },
];

const model = genAI.getGenerativeModel({ model: "MODEL_NAME", safetySettings });

Możesz też skonfigurować więcej niż jedno ustawienie bezpieczeństwa:

const safetySettings = [
  {
    category: HarmCategory.HARM_CATEGORY_HARASSMENT,
    threshold: HarmBlockThreshold.BLOCK_ONLY_HIGH,
  },
  {
    category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
    threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
  },
];

Co dalej

  • Projektowanie promptów to proces tworzenia promptów, które wywołują pożądaną odpowiedź od modeli językowych. Tworzenie dobrze uporządkowanych promptów to klucz do zapewnienia dokładnych i wysokiej jakości odpowiedzi z modelu językowego. Poznaj sprawdzone metody pisania promptów.

  • Gemini oferuje kilka wersji modelu, które spełniają różne potrzeby dotyczące na przykład typów danych wejściowych i złożoności, implementacji czatu lub innych zadań związanych z językiem okna czy ograniczeń rozmiaru. Dowiedz się więcej o dostępnych modelach Gemini.

  • Gemini udostępnia opcje, dzięki którym możesz poprosić o zwiększenie limitu częstotliwości. Dla modeli Gemini Pro limit szybkości wynosi 60 żądań na minutę (RPM).