Caching

Metoda: CacheContents.create

Tworzy zasób CachedContent.

Punkt końcowy

post https://generativelanguage.googleapis.com/v1beta/cachedContents
.

Treść żądania

Treść żądania zawiera wystąpienie elementu CachedContent.

Przykładowe żądanie

Podstawowe

Python

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)
print(cache)

model = genai.GenerativeModel.from_cached_content(cache)
response = model.generate_content("Please summarize this transcript")
print(response.text)

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
// import { GoogleGenerativeAI } from "@google/generative-ai";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});

console.log(cacheResult);

const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModelFromCachedContent(cacheResult);
const result = await model.generateContent(
  "Please summarize this transcript.",
);
console.log(result.response.text());

Nazwa nadawcy

Python

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)
cache_name = cache.name  # Save the name for later

# Later
cache = genai.caching.CachedContent.get(cache_name)
apollo_model = genai.GenerativeModel.from_cached_content(cache)
response = apollo_model.generate_content("Find a lighthearted moment from this transcript")
print(response.text)

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
// import { GoogleGenerativeAI } from "@google/generative-ai";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});
const cacheName = cacheResult.name; // Save the name for later.

// Later
const getCacheResult = await cacheManager.get(cacheName);
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModelFromCachedContent(getCacheResult);
model.generateContent("Please summarize this transcript.");

Z czatu

Python

model_name = "gemini-1.5-flash-001"
system_instruction = "You are an expert analyzing transcripts."

model = genai.GenerativeModel(model_name=model_name, system_instruction=system_instruction)
chat = model.start_chat()
document = genai.upload_file(path=media / "a11.txt")
response = chat.send_message(["Hi, could you summarize this transcript?", document])
print("\n\nmodel:  ", response.text)
response = chat.send_message(
    ["Okay, could you tell me more about the trans-lunar injection"]
)
print("\n\nmodel:  ", response.text)

# To cache the conversation so far, pass the chat history as the list of "contents".
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction=system_instruction,
    contents=chat.history,
)
model = genai.GenerativeModel.from_cached_content(cached_content=cache)

# Continue the chat where you left off.
chat = model.start_chat()
response = chat.send_message(
    "I didn't understand that last part, could you explain it in simpler language?"
)
print("\n\nmodel:  ", response.text)

Node.js

// Make sure to include these imports:
// import { GoogleGenerativeAI } from "@google/generative-ai";
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

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

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

let result = await chat.sendMessage([
  "Hi, could you summarize this transcript?",
  {
    fileData: {
      fileUri: uploadResult.file.uri,
      mimeType: uploadResult.file.mimeType,
    },
  },
]);
console.log(`\n\nmodel: ${result.response.text()}`);
result = await chat.sendMessage(
  "Okay, could you tell me more about the trans-lunar injection",
);
console.log(`\n\nmodel: ${result.response.text()}`);

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: await chat.getHistory(),
});

const newModel = genAI.getGenerativeModelFromCachedContent(cacheResult);

const newChat = newModel.startChat();
result = await newChat.sendMessage(
  "I didn't understand that last part, could you explain it in simpler language?",
);
console.log(`\n\nmodel: ${result.response.text()}`);

Treść odpowiedzi

Jeśli operacja się uda, treść odpowiedzi będzie zawierała nowo utworzoną instancję CachedContent.

Metoda: CacheContents.list

Wyświetla zawartość CachedContent.

Punkt końcowy

pobierz https://generativelanguage.googleapis.com/v1beta/cachedContents
.

Parametry zapytania

pageSize integer

Opcjonalnie: Maksymalna liczba treści z pamięci podręcznej do zwrócenia. Usługa może zwrócić mniej niż ta wartość. Jeśli nie określono inaczej, zostanie zwrócona domyślna (poniżej maksymalnej) liczba produktów. Maksymalna wartość to 1000. wartości powyżej 1000 zostaną zmienione na 1000.

pageToken string

Opcjonalnie: Token strony otrzymany z poprzedniego wywołania funkcji cachedContents.list. Podaj go, aby pobrać kolejną stronę.

Podczas dzielenia na strony wszystkie pozostałe parametry podane w narzędziu cachedContents.list muszą być zgodne z wywołaniem, które dostarczyło token strony.

Treść żądania

Treść żądania musi być pusta.

Treść odpowiedzi

Odpowiedź z listą CachedContents.

W przypadku powodzenia treść żądania zawiera dane o następującej strukturze:

Pola
cachedContents[] object (CachedContent)

Lista treści z pamięci podręcznej.

nextPageToken string

Token, który może zostać wysłany jako pageToken w celu pobrania następnej strony. Jeśli pominiesz to pole, nie będzie kolejnych stron.

Zapis JSON 
{
  "cachedContents": [
    {
      object (CachedContent)
    }
  ],
  "nextPageToken": string
}

Metoda: CacheContents.get

Odczytuje zasób CachedContent.

Punkt końcowy

pobierz https://generativelanguage.googleapis.com/v1beta/{name=cachedContents/*}
.

Parametry ścieżki

name string

Wymagane. Nazwa zasobu odwołująca się do wpisu w pamięci podręcznej treści. Format: cachedContents/{id} Przyjmuje postać cachedContents/{cachedcontent}.

Treść żądania

Treść żądania musi być pusta.

Przykładowe żądanie

Python

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)
print(genai.caching.CachedContent.get(name=cache.name))

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});
const cacheGetResult = await cacheManager.get(cacheResult.name);
console.log(cacheGetResult);

Treść odpowiedzi

W przypadku powodzenia treść odpowiedzi obejmuje wystąpienie elementu CachedContent.

Metoda: bufferContents.patch

Aktualizuje zasób CachedContent (tylko datę wygaśnięcia można zaktualizować).

Punkt końcowy

poprawka https://generativelanguage.googleapis.com/v1beta/{cachedContent.name=cachedContents/*}

PATCH https://generativelanguage.googleapis.com/v1beta/{cachedContent.name=cachedContents/*}

Parametry ścieżki

cachedContent.name string

Opcjonalnie: Identyfikator. Nazwa zasobu odnosząca się do treści zapisanej w pamięci podręcznej. Format: cachedContents/{id} Przyjmuje postać cachedContents/{cachedcontent}.

Parametry zapytania

updateMask string (FieldMask format)

Lista pól do zaktualizowania.

Jest to rozdzielana przecinkami lista w pełni kwalifikowanych nazw pól. Przykład: "user.displayName,photo".

Treść żądania

Treść żądania zawiera wystąpienie elementu CachedContent.

Przykładowe żądanie

Python

import datetime

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)

# You can update the ttl
cache.update(ttl=datetime.timedelta(hours=2))
print(f"After update:\n {cache}")

# Or you can update the expire_time
cache.update(expire_time=datetime.datetime.now() + datetime.timedelta(minutes=15))

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});
console.log("initial cache data:", cacheResult);
const cacheUpdateResult = await cacheManager.update(cacheResult.name, {
  cachedContent: {
    // 2 hours
    ttlSeconds: 60 * 60 * 2,
  },
});
console.log("updated cache data:", cacheUpdateResult);

Treść odpowiedzi

W przypadku powodzenia treść odpowiedzi obejmuje wystąpienie elementu CachedContent.

Metoda: CacheContents.delete

Usuwa zasób CachedContent.

Punkt końcowy

usuń https://generativelanguage.googleapis.com/v1beta/{name=cachedContents/*}
.

Parametry ścieżki

name string

Wymagane. Nazwa zasobu odnosi się do wpisu w pamięci podręcznej treści. Format: cachedContents/{id}. Przyjmuje postać cachedContents/{cachedcontent}.

Treść żądania

Treść żądania musi być pusta.

Przykładowe żądanie

Python

document = genai.upload_file(path=media / "a11.txt")
model_name = "gemini-1.5-flash-001"
cache = genai.caching.CachedContent.create(
    model=model_name,
    system_instruction="You are an expert analyzing transcripts.",
    contents=[document],
)
cache.delete()

Node.js

// Make sure to include these imports:
// import { GoogleAICacheManager, GoogleAIFileManager } from "@google/generative-ai/server";
const cacheManager = new GoogleAICacheManager(process.env.API_KEY);
const fileManager = new GoogleAIFileManager(process.env.API_KEY);

const uploadResult = await fileManager.uploadFile(`${mediaPath}/a11.txt`, {
  mimeType: "text/plain",
});

const cacheResult = await cacheManager.create({
  model: "models/gemini-1.5-flash-001",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: uploadResult.file.uri,
            mimeType: uploadResult.file.mimeType,
          },
        },
      ],
    },
  ],
});
await cacheManager.delete(cacheResult.name);

Treść odpowiedzi

Jeśli operacja się uda, treść odpowiedzi będzie pusta.

Zasób REST: CacheContents

Zasób: CachedContent

Treści, które zostały wstępnie przetworzone i można ich użyć w kolejnych żądaniach kierowanych do GenerativeService.

Treści z pamięci podręcznej można używać tylko z modelem, dla którego została utworzona.

Zapis JSON 
{
  "contents": [
    {
      object (Content)
    }
  ],
  "tools": [
    {
      object (Tool)
    }
  ],
  "createTime": string,
  "updateTime": string,
  "usageMetadata": {
    object (UsageMetadata)
  },

  // Union field expiration can be only one of the following:
  "expireTime": string,
  "ttl": string
  // End of list of possible types for union field expiration.
  "name": string,
  "displayName": string,
  "model": string,
  "systemInstruction": {
    object (Content)
  },
  "toolConfig": {
    object (ToolConfig)
  }
}
Pola
contents[] object (Content)

Opcjonalnie: Tylko dane wejściowe. Stała. Zawartość do pamięci podręcznej.

tools[] object (Tool)

Opcjonalnie: Tylko dane wejściowe. Stała. Lista właściwości Tools, których model może używać do wygenerowania następnej odpowiedzi

createTime string (Timestamp format)

Tylko dane wyjściowe. Czas utworzenia wpisu w pamięci podręcznej.

Sygnatura czasowa w RFC3339 UTC „Zulu” z rozdzielczością nanosekundową i maksymalnie 9 cyframi po przecinku. Przykłady: "2014-10-02T15:01:23Z" i "2014-10-02T15:01:23.045123456Z".

updateTime string (Timestamp format)

Tylko dane wyjściowe. Czas ostatniej aktualizacji wpisu w pamięci podręcznej według czasu UTC.

Sygnatura czasowa w RFC3339 UTC „Zulu” z rozdzielczością nanosekundową i maksymalnie 9 cyframi po przecinku. Przykłady: "2014-10-02T15:01:23Z" i "2014-10-02T15:01:23.045123456Z".

usageMetadata object (UsageMetadata)

Tylko dane wyjściowe. Metadane dotyczące wykorzystania treści zapisanych w pamięci podręcznej.

Pole sumy expiration. Określa, kiedy zasób wygaśnie. expiration może mieć tylko jedną z tych wartości:
expireTime string (Timestamp format)

Sygnatura czasowa UTC wskazująca, kiedy zasób jest uznawany za nieaktualny. Wartość ta jest zawsze podawana na danych wyjściowych, niezależnie od tego, co zostało przesłane na dane wejściowe.

Sygnatura czasowa w RFC3339 UTC „Zulu” z rozdzielczością nanosekundową i maksymalnie 9 cyframi po przecinku. Przykłady: "2014-10-02T15:01:23Z" i "2014-10-02T15:01:23.045123456Z".

ttl string (Duration format)

Tylko dane wejściowe. Nowa wartość TTL dla tego zasobu, tylko dane wejściowe.

Czas trwania w sekundach składający się z maksymalnie 9 cyfr po przecinku i kończący się „s”. Przykład: "3.5s".

name string

Opcjonalnie: Identyfikator. Nazwa zasobu odnosząca się do treści zapisanej w pamięci podręcznej. Format: cachedContents/{id}

displayName string

Opcjonalnie: Stała. Wygenerowana przez użytkownika rozpoznawalna wyświetlana nazwa treści z pamięci podręcznej. Maksymalnie 128 znaków Unicode.

model string

Wymagane. Stała. Nazwa elementu (Model), który ma być używany w przypadku treści w pamięci podręcznej. Format: models/{model}

systemInstruction object (Content)

Opcjonalnie: Tylko dane wejściowe. Stała. Instrukcja systemowa ustawiona przez dewelopera. Obecnie tylko tekstowe.

toolConfig object (ToolConfig)

Opcjonalnie: Tylko dane wejściowe. Stała. Konfiguracja narzędzia. Ta konfiguracja jest współdzielona dla wszystkich narzędzi.

Treść

Podstawowy uporządkowany typ danych zawierający wieloczęściową treść wiadomości.

Pole Content zawiera pole role określające producenta elementu Content oraz pole parts zawierające dane wieloczęściowe, które zawierają treść kolejki wiadomości.

Zapis JSON 
{
  "parts": [
    {
      object (Part)
    }
  ],
  "role": string
}
Pola
parts[] object (Part)

Zamówiono Parts, które tworzą jedną wiadomość. Części mogą mieć różne typy MIME.

role string

Opcjonalnie: Producent treści. Musi mieć wartość „user” (użytkownik). czy „model”.

Ta opcja jest przydatna w przypadku rozmów wieloetapowych. W przeciwnym razie pole może pozostać puste lub nieskonfigurowane.

Część

Typ danych zawierający multimedia, które są częścią wieloczęściowej wiadomości Content.

Element Part składa się z danych, które mają powiązany typ danych. Element Part może zawierać tylko 1 z akceptowanych typów w polu Part.data.

Jeśli pole inlineData jest wypełnione nieprzetworzonymi bajtami, Part musi mieć stały typ MIME IANA identyfikujący typ i podtyp mediów.

Zapis JSON 
{

  // Union field data can be only one of the following:
  "text": string,
  "inlineData": {
    object (Blob)
  },
  "functionCall": {
    object (FunctionCall)
  },
  "functionResponse": {
    object (FunctionResponse)
  },
  "fileData": {
    object (FileData)
  },
  "executableCode": {
    object (ExecutableCode)
  },
  "codeExecutionResult": {
    object (CodeExecutionResult)
  }
  // End of list of possible types for union field data.
}
Pola

Pole sumy data.

data może mieć tylko jedną z tych wartości:

text string

Tekst wbudowany.

inlineData object (Blob)

Wbudowane bajty multimediów.

functionCall object (FunctionCall)

Prognozowana wartość FunctionCall zwrócona z modelu, która zawiera ciąg reprezentujący element FunctionDeclaration.name z argumentami i ich wartościami.

functionResponse object (FunctionResponse)

Wynikowe dane wyjściowe funkcji FunctionCall, które zawierają ciąg znaków reprezentujący obiekt FunctionDeclaration.name, i uporządkowany obiekt JSON zawierający dowolne dane wyjściowe funkcji, są używane jako kontekst dla modelu.

fileData object (FileData)

Dane oparte na identyfikatorze URI.

executableCode object (ExecutableCode)

Kod wygenerowany przez model, który ma być wykonany.

codeExecutionResult object (CodeExecutionResult)

Wynik wykonywania zadania ExecutableCode.

Blob

Nieprzetworzone bajty multimediów.

Tekst nie powinien być wysyłany jako nieprzetworzone bajty – używaj parametru „text” .

Zapis JSON 
{
  "mimeType": string,
  "data": string
}
Pola
mimeType string

Standardowy typ MIME danych źródłowych wg IANA. Przykłady: – obraz/png – obraz/jpeg. Jeśli zostanie podany nieobsługiwany typ MIME, zostanie zwrócony błąd. Pełną listę obsługiwanych formatów znajdziesz w artykule o obsługiwanych formatach plików.

data string (bytes format)

Nieprzetworzone bajty formatów multimediów.

Ciąg zakodowany w formacie base64.

FunctionCall

Prognozowana wartość FunctionCall zwrócona przez model, która zawiera ciąg reprezentujący element FunctionDeclaration.name z argumentami i ich wartościami.

Zapis JSON 
{
  "name": string,
  "args": {
    object
  }
}
Pola
name string

Wymagane. Nazwa funkcji do wywołania. Nazwa musi mieć format a–z, A–Z lub 0–9, albo zawierać podkreślenia i myślniki o maksymalnej długości 63 znaki.

args object (Struct format)

Opcjonalnie: Parametry i wartości funkcji w formacie obiektu JSON.

FunctionResponse

Wynikowe dane wyjściowe z funkcji FunctionCall, które zawierają ciąg znaków reprezentujący obiekt FunctionDeclaration.name, oraz uporządkowany obiekt JSON zawierający dowolne dane wyjściowe funkcji, są używane jako kontekst dla modelu. Powinien on zawierać wynik funkcji FunctionCall utworzonej na podstawie prognozy modelu.

Zapis JSON 
{
  "name": string,
  "response": {
    object
  }
}
Pola
name string

Wymagane. Nazwa funkcji do wywołania. Nazwa musi mieć format a–z, A–Z lub 0–9, albo zawierać podkreślenia i myślniki o maksymalnej długości 63 znaki.

response object (Struct format)

Wymagane. Odpowiedź funkcji w formacie obiektu JSON.

FileData

Dane oparte na identyfikatorze URI.

Zapis JSON 
{
  "mimeType": string,
  "fileUri": string
}
Pola
mimeType string

Opcjonalnie: Standardowy typ MIME danych źródłowych wg IANA.

fileUri string

Wymagane. Identyfikator URI.

ExecutableCode

Kod wygenerowany przez model, który ma zostać wykonany, a jego wynik zwrócony do modelu.

Wygenerowany tylko przy użyciu narzędzia CodeExecution, w którym kod zostanie automatycznie wykonany oraz wygenerowany zostanie odpowiedni element CodeExecutionResult.

Zapis JSON 
{
  "language": enum (Language),
  "code": string
}
Pola
language enum (Language)

Wymagane. Język programowania urządzenia code.

code string

Wymagane. Kod do wykonania.

Język

Obsługiwane języki programowania dla wygenerowanego kodu.

Wartości w polu enum
LANGUAGE_UNSPECIFIED Nieokreślony język. Nie należy używać tej wartości.
PYTHON Python >= 3.10. Dostępne są funkcje numpy i simpy.

CodeExecutionResult

Wynik wykonywania zadania ExecutableCode.

Wygenerowane tylko wtedy, gdy używana jest zasada CodeExecution i zawsze następuje po part zawierającej ExecutableCode.

Zapis JSON 
{
  "outcome": enum (Outcome),
  "output": string
}
Pola
outcome enum (Outcome)

Wymagane. Wynik wykonania kodu.

output string

Opcjonalnie: Zawiera parametr stdout, gdy wykonanie kodu zakończyło się powodzeniem, stderr lub inny opis.

Wynik

Lista możliwych wyników wykonania kodu.

Wartości w polu enum
OUTCOME_UNSPECIFIED Stan nieokreślony. Nie należy używać tej wartości.
OUTCOME_OK Wykonanie kodu zostało ukończone.
OUTCOME_FAILED Wykonanie kodu zostało zakończone, ale wystąpił błąd. Pole stderr powinno zawierać przyczynę.
OUTCOME_DEADLINE_EXCEEDED Wykonanie kodu trwało zbyt długo i zostało anulowane. Może się zdarzyć, że pojawią się częściowe dane wyjściowe.

Narzędzie

Szczegóły narzędzia, których model może używać do generowania odpowiedzi.

Tool to fragment kodu, który umożliwia systemowi wchodzenie w interakcję z zewnętrznymi systemami w celu wykonania działania lub zestawu działań poza zakresem wiedzy i zakresu modelu.

Zapis JSON 
{
  "functionDeclarations": [
    {
      object (FunctionDeclaration)
    }
  ],
  "codeExecution": {
    object (CodeExecution)
  }
}
Pola
functionDeclarations[] object (FunctionDeclaration)

Opcjonalnie: Lista elementów FunctionDeclarations dostępnych dla modelu, które mogą być używane do wywoływania funkcji.

Model lub system nie wykonuje funkcji. Zamiast tego zdefiniowana funkcja może zostać zwrócona jako [wywołanie funkcji][content.part.function_call] z argumentami po stronie klienta do wykonania. Model może zdecydować o wywołaniu podzbioru tych funkcji, wypełniając w odpowiedzi [wywołanie funkcji][content.part.function_call]. Kolejny etap wątku może zawierać odpowiedź [FunctionResponse][content.part.function_response] z „funkcją” [content.role]. w kontekście następnej generacji modelu.

codeExecution object (CodeExecution)

Opcjonalnie: Umożliwia modelowi wykonywanie kodu w ramach generowania.

FunctionDeclaration

Uporządkowane przedstawienie deklaracji funkcji zgodnie ze specyfikacją OpenAPI 3.03. Ta deklaracja zawiera nazwę funkcji i jej parametry. Ta deklaracja funkcji to reprezentacja bloku kodu, który może być używany przez model jako Tool i wykonywany przez klienta.

Zapis JSON 
{
  "name": string,
  "description": string,
  "parameters": {
    object (Schema)
  }
}
Pola
name string

Wymagane. Nazwa funkcji. Nazwa musi mieć format a–z, A–Z lub 0–9, albo zawierać podkreślenia i myślniki o maksymalnej długości 63 znaki.

description string

Wymagane. Krótki opis funkcji.

parameters object (Schema)

Opcjonalnie: Opisuje parametry tej funkcji. Odzwierciedla klucz ciągu znaków obiektu parametru Open API 3.03: nazwę parametru. W nazwach parametrów rozróżniana jest wielkość liter. Wartość schematu: schemat określający typ parametru.

Schemat

Obiekt Schema umożliwia definiowanie typów danych wejściowych i wyjściowych. Mogą to być obiekty, ale też obiekty podstawowe i tablice. Reprezentuje wybrany podzbiór obiektu schematu OpenAPI 3.0.

Zapis JSON 
{
  "type": enum (Type),
  "format": string,
  "description": string,
  "nullable": boolean,
  "enum": [
    string
  ],
  "properties": {
    string: {
      object (Schema)
    },
    ...
  },
  "required": [
    string
  ],
  "items": {
    object (Schema)
  }
}
Pola
type enum (Type)

Wymagane. Typ danych.

format string

Opcjonalnie: Format danych. Jest używana tylko w przypadku podstawowych typów danych. Obsługiwane formaty: dla typu NUMBER: liczba zmiennoprzecinkowa, podwójna (liczba całkowita: int32, int64) dla typu typu LICZBA: liczba zmiennoprzecinkowa

description string

Opcjonalnie: Krótki opis parametru. Może zawierać przykłady użycia. Opis parametru może mieć format Markdown.

nullable boolean

Opcjonalnie: Wskazuje, czy wartość może być pusta.

enum[] string

Opcjonalnie: Możliwe wartości elementu Type.STRING w formacie wyliczenia. Kierunek wyliczeniowy można na przykład zdefiniować jako : {type:STRING, format:enum, enum:["WSCHÓD", PÓŁNOC", "SOUTH", "WEST"]}

properties map (key: string, value: object (Schema))

Opcjonalnie: Właściwości obiektu Type.OBJECT.

Obiekt zawierający listę par "key": value. Przykład: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

required[] string

Opcjonalnie: Wymagane właściwości obiektu Type.OBJECT.

items object (Schema)

Opcjonalnie: Schemat elementów pliku Type.ARRAY.

Typ

Typ zawiera listę typów danych OpenAPI zgodnie z definicją zawartą w https://spec.openapis.org/oas/v3.0.3#data-types.

Wartości w polu enum
TYPE_UNSPECIFIED Nie określono i nie należy go używać.
STRING Typ ciągu znaków.
NUMBER Typ numeru.
INTEGER Typ liczby całkowitej.
BOOLEAN Typ wartości logicznej.
ARRAY Typ tablicy.
OBJECT Typ obiektu.

CodeExecution

Ten typ nie zawiera pól.

Narzędzie, które wykonuje kod wygenerowany przez model i automatycznie zwraca wynik do modelu.

Zobacz też ExecutableCode i CodeExecutionResult, które są generowane tylko podczas korzystania z tego narzędzia.

ToolConfig

Konfiguracja narzędzia zawierająca parametry służące do określania użycia funkcji Tool w żądaniu.

Zapis JSON 
{
  "functionCallingConfig": {
    object (FunctionCallingConfig)
  }
}
Pola
functionCallingConfig object (FunctionCallingConfig)

Opcjonalnie: Funkcja wywołująca konfigurację.

FunctionCallingConfig

Konfiguracja do określania zachowania wywoływania funkcji.

Zapis JSON 
{
  "mode": enum (Mode),
  "allowedFunctionNames": [
    string
  ]
}
Pola
mode enum (Mode)

Opcjonalnie: Określa tryb, w którym mają być wykonywane wywołania funkcji. Jeśli nie określono inaczej, domyślną wartością będzie AUTO.

allowedFunctionNames[] string

Opcjonalnie: Zbiór nazw funkcji, które po podaniu ograniczają funkcje wywoływane przez model.

Tę wartość należy ustawiać tylko wtedy, gdy tryb ma wartość DOWOLNY. Nazwy funkcji powinny być takie same jak w parametrze [FunctionDeklaracja.nazwa]. Gdy tryb jest ustawiony na DOWOLNY, model przewiduje wywołanie funkcji na podstawie podanego zestawu nazw funkcji.

Tryb

Definiuje sposób wykonania wywoływania funkcji przez zdefiniowanie trybu wykonania.

Wartości w polu enum
MODE_UNSPECIFIED Tryb wywoływania funkcji o nieokreślonej wartości. Nie należy używać tej wartości.
AUTO Domyślny model działania decyduje o prognozowaniu wywołania funkcji lub odpowiedzi w języku naturalnym.
ANY Model jest ograniczony do prognozowania tylko wywołania funkcji. Jeśli „allowedFunctionNames” prognozowane wywołanie funkcji zostanie ograniczone do dowolnej z tych funkcji: „allowedFunctionNames”. W przeciwnym razie prognozowanym wywołaniem funkcji będzie dowolna z podanych „deklaracji funkcji”.
NONE Model nie będzie przewidywać żadnego wywołania funkcji. Zachowanie modelu jest takie samo jak w przypadku braku deklaracji funkcji.

UsageMetadata

Metadane dotyczące wykorzystania treści zapisanych w pamięci podręcznej.

Zapis JSON 
{
  "totalTokenCount": integer
}
Pola
totalTokenCount integer

Łączna liczba tokenów wykorzystanych przez pamięć podręczną.