Interfejs Gemini API umożliwia generowanie wspomagane wyszukiwaniem (RAG) za pomocą narzędzia wyszukiwania plików. Narzędzie wyszukiwania plików importuje, dzieli na fragmenty i indeksuje Twoje dane, aby umożliwić szybkie wyszukiwanie odpowiednich informacji na podstawie podanego prompta. Te informacje są następnie używane jako kontekst dla modelu, co pozwala mu udzielać dokładniejszych i trafniejszych odpowiedzi.
Aby narzędzie wyszukiwania plików było proste i niedrogie dla deweloperów, udostępniamy bezpłatnie przechowywanie plików i generowanie wektorów dystrybucyjnych w czasie wykonywania zapytań. Płacisz tylko za tworzenie wektorów dystrybucyjnych podczas pierwszego indeksowania plików (według obowiązującej ceny modelu wektorów dystrybucyjnych) oraz za zwykłe tokeny wejściowe i wyjściowe modelu Gemini. Ten nowy model rozliczeń sprawia, że narzędzie wyszukiwania plików jest łatwiejsze i bardziej opłacalne w tworzeniu i skalowaniu.
Bezpośrednie przesyłanie do magazynu narzędzia wyszukiwania plików
Ten przykład pokazuje, jak bezpośrednio przesłać plik do magazynu narzędzia wyszukiwania plików:
Python
from google import genai
from google.genai import types
import time
client = genai.Client()
# File name will be visible in citations
file_search_store = client.file_search_stores.create(config={'display_name': 'your-fileSearchStore-name'})
operation = client.file_search_stores.upload_to_file_search_store(
file='sample.txt',
file_search_store_name=file_search_store.name,
config={
'display_name' : 'display-file-name',
}
)
while not operation.done:
time.sleep(5)
operation = client.operations.get(operation)
response = client.models.generate_content(
model="gemini-3-flash-preview",
contents="""Can you tell me about [insert question]""",
config=types.GenerateContentConfig(
tools=[
types.Tool(
file_search=types.FileSearch(
file_search_store_names=[file_search_store.name]
)
)
]
)
)
print(response.text)
JavaScript
const { GoogleGenAI } = require('@google/genai');
const ai = new GoogleGenAI({});
async function run() {
// File name will be visible in citations
const fileSearchStore = await ai.fileSearchStores.create({
config: { displayName: 'your-fileSearchStore-name' }
});
let operation = await ai.fileSearchStores.uploadToFileSearchStore({
file: 'file.txt',
fileSearchStoreName: fileSearchStore.name,
config: {
displayName: 'file-name',
}
});
while (!operation.done) {
await new Promise(resolve => setTimeout(resolve, 5000));
operation = await ai.operations.get({ operation });
}
const response = await ai.models.generateContent({
model: "gemini-3-flash-preview",
contents: "Can you tell me about [insert question]",
config: {
tools: [
{
fileSearch: {
fileSearchStoreNames: [fileSearchStore.name]
}
}
]
}
});
console.log(response.text);
}
run();
Więcej informacji znajdziesz w dokumentacji API dotyczącej funkcji uploadToFileSearchStore.
Importowanie plików
Możesz też przesłać istniejący plik i zaimportować go do magazynu narzędzia wyszukiwania plików:
Python
from google import genai
from google.genai import types
import time
client = genai.Client()
# File name will be visible in citations
sample_file = client.files.upload(file='sample.txt', config={'name': 'display_file_name'})
file_search_store = client.file_search_stores.create(config={'display_name': 'your-fileSearchStore-name'})
operation = client.file_search_stores.import_file(
file_search_store_name=file_search_store.name,
file_name=sample_file.name
)
while not operation.done:
time.sleep(5)
operation = client.operations.get(operation)
response = client.models.generate_content(
model="gemini-3-flash-preview",
contents="""Can you tell me about [insert question]""",
config=types.GenerateContentConfig(
tools=[
types.Tool(
file_search=types.FileSearch(
file_search_store_names=[file_search_store.name]
)
)
]
)
)
print(response.text)
JavaScript
const { GoogleGenAI } = require('@google/genai');
const ai = new GoogleGenAI({});
async function run() {
// File name will be visible in citations
const sampleFile = await ai.files.upload({
file: 'sample.txt',
config: { name: 'file-name' }
});
const fileSearchStore = await ai.fileSearchStores.create({
config: { displayName: 'your-fileSearchStore-name' }
});
let operation = await ai.fileSearchStores.importFile({
fileSearchStoreName: fileSearchStore.name,
fileName: sampleFile.name
});
while (!operation.done) {
await new Promise(resolve => setTimeout(resolve, 5000));
operation = await ai.operations.get({ operation: operation });
}
const response = await ai.models.generateContent({
model: "gemini-3-flash-preview",
contents: "Can you tell me about [insert question]",
config: {
tools: [
{
fileSearch: {
fileSearchStoreNames: [fileSearchStore.name]
}
}
]
}
});
console.log(response.text);
}
run();
Więcej informacji znajdziesz w dokumentacji API dotyczącej funkcji importFile.
Konfiguracja dzielenia na fragmenty
Gdy importujesz plik do magazynu narzędzia wyszukiwania plików, jest on automatycznie dzielony na fragmenty, osadzany, indeksowany i przesyłany do magazynu narzędzia wyszukiwania plików. Jeśli
chcesz mieć większą kontrolę nad strategią dzielenia na fragmenty, możesz określić
chunking_config ustawienie
aby ustawić maksymalną liczbę tokenów na fragment i maksymalną liczbę nakładających się
tokenów.
Python
from google import genai
from google.genai import types
import time
client = genai.Client()
operation = client.file_search_stores.upload_to_file_search_store(
file_search_store_name=file_search_store.name,
file_name=sample_file.name,
config={
'chunking_config': {
'white_space_config': {
'max_tokens_per_chunk': 200,
'max_overlap_tokens': 20
}
}
}
)
while not operation.done:
time.sleep(5)
operation = client.operations.get(operation)
print("Custom chunking complete.")
JavaScript
const { GoogleGenAI } = require('@google/genai');
const ai = new GoogleGenAI({});
let operation = await ai.fileSearchStores.uploadToFileSearchStore({
file: 'file.txt',
fileSearchStoreName: fileSearchStore.name,
config: {
displayName: 'file-name',
chunkingConfig: {
whiteSpaceConfig: {
maxTokensPerChunk: 200,
maxOverlapTokens: 20
}
}
}
});
while (!operation.done) {
await new Promise(resolve => setTimeout(resolve, 5000));
operation = await ai.operations.get({ operation });
}
console.log("Custom chunking complete.");
Aby używać magazynu narzędzia wyszukiwania plików, przekaż go jako narzędzie do metody generateContent, jak pokazano w przykładach przesyłania i importowania.
Jak to działa
Narzędzie wyszukiwania plików używa techniki zwanej wyszukiwaniem semantycznym, aby znaleźć informacje odpowiednie dla prompta użytkownika. W przeciwieństwie do standardowego wyszukiwania opartego na słowach kluczowych wyszukiwanie semantyczne rozumie znaczenie i kontekst zapytania.
Gdy importujesz plik, jest on przekształcany w reprezentacje numeryczne zwane wektorami dystrybucyjnymi, które zawierają znaczenie semantyczne tekstu. Te wektory dystrybucyjne są przechowywane w specjalnej bazie danych narzędzia wyszukiwania plików. Gdy wysyłasz zapytanie, jest ono również przekształcane w wektor dystrybucyjny. Następnie system przeprowadza wyszukiwanie plików, aby znaleźć najbardziej podobne i odpowiednie fragmenty dokumentów w magazynie narzędzia wyszukiwania plików.
W przypadku wektorów dystrybucyjnych i plików nie ma czasu życia (TTL). Są one przechowywane do momentu ręcznego usunięcia lub wycofania modelu.
Oto podział procesu korzystania z interfejsu uploadToFileSearchStore API wyszukiwania plików:
Utwórz magazyn narzędzia wyszukiwania plików: magazyn narzędzia wyszukiwania plików zawiera przetworzone dane z Twoich plików. Jest to trwały kontener na wektory dystrybucyjne, na których będzie działać wyszukiwanie semantyczne.
Prześlij plik i zaimportuj go do magazynu narzędzia wyszukiwania plików: jednocześnie prześlij plik i zaimportuj wyniki do magazynu narzędzia wyszukiwania plików. Spowoduje to utworzenie tymczasowego obiektu
File, który jest odniesieniem do Twojego nieprzetworzonego dokumentu. Te dane są następnie dzielone na fragmenty, przekształcane w wektory dystrybucyjne narzędzia wyszukiwania plików i indeksowane. ObiektFilezostanie usunięty po 48 godzinach, a dane zaimportowane do magazynu narzędzia wyszukiwania plików będą przechowywane bezterminowo, dopóki nie zdecydujesz się ich usunąć.Wysyłaj zapytania za pomocą narzędzia wyszukiwania plików: na koniec użyj narzędzia
FileSearchw wywołaniugenerateContent. W konfiguracji narzędzia określFileSearchRetrievalResource, który wskazujeFileSearchStore, w którym chcesz wyszukiwać. Informuje to model, aby przeprowadził wyszukiwanie semantyczne w tym konkretnym magazynie narzędzia wyszukiwania plików w celu znalezienia odpowiednich informacji, które posłużą do ugruntowania odpowiedzi.
Na tym diagramie linia przerywana od Dokumentów do Modelu wektorów dystrybucyjnych
(przy użyciu gemini-embedding-001)
reprezentuje interfejs uploadToFileSearchStore API (z pominięciem Magazynu plików).
W przeciwnym razie użycie interfejsu Files API do oddzielnego tworzenia
a następnie importowania plików przenosi proces indeksowania z Dokumentów do
Magazynu plików, a następnie do Modelu wektorów dystrybucyjnych.
Magazyny narzędzia wyszukiwania plików
Magazyn narzędzia wyszukiwania plików to kontener na wektory dystrybucyjne dokumentów. Nieprzetworzone pliki przesłane za pomocą interfejsu File API są usuwane po 48 godzinach, ale dane zaimportowane do magazynu narzędzia wyszukiwania plików są przechowywane bezterminowo, dopóki nie usuniesz ich ręcznie. Możesz utworzyć kilka magazynów narzędzia wyszukiwania plików, aby uporządkować dokumenty. Interfejs FileSearchStore API umożliwia tworzenie, wyświetlanie, pobieranie i usuwanie magazynów narzędzia wyszukiwania plików. Nazwy magazynów narzędzia wyszukiwania plików mają zasięg globalny.
Oto kilka przykładów zarządzania magazynami narzędzia wyszukiwania plików:
Python
file_search_store = client.file_search_stores.create(config={'display_name': 'my-file_search-store-123'})
for file_search_store in client.file_search_stores.list():
print(file_search_store)
my_file_search_store = client.file_search_stores.get(name='fileSearchStores/my-file_search-store-123')
client.file_search_stores.delete(name='fileSearchStores/my-file_search-store-123', config={'force': True})
JavaScript
const fileSearchStore = await ai.fileSearchStores.create({
config: { displayName: 'my-file_search-store-123' }
});
const fileSearchStores = await ai.fileSearchStores.list();
for await (const store of fileSearchStores) {
console.log(store);
}
const myFileSearchStore = await ai.fileSearchStores.get({
name: 'fileSearchStores/my-file_search-store-123'
});
await ai.fileSearchStores.delete({
name: 'fileSearchStores/my-file_search-store-123',
config: { force: true }
});
REST
curl -X POST "https://generativelanguage.googleapis.com/v1beta/fileSearchStores?key=${GEMINI_API_KEY}" \
-H "Content-Type: application/json"
-d '{ "displayName": "My Store" }'
curl "https://generativelanguage.googleapis.com/v1beta/fileSearchStores?key=${GEMINI_API_KEY}" \
curl "https://generativelanguage.googleapis.com/v1beta/fileSearchStores/my-file_search-store-123?key=${GEMINI_API_KEY}"
curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/fileSearchStores/my-file_search-store-123?key=${GEMINI_API_KEY}"
Dokumenty narzędzia wyszukiwania plików
Za pomocą interfejsu
File Search Documents API możesz zarządzać poszczególnymi dokumentami w magazynach plików, aby list każdy dokument
w magazynie narzędzia wyszukiwania plików, get informacje o dokumencie i delete dokument
według nazwy.
Python
for document_in_store in client.file_search_stores.documents.list(parent='fileSearchStores/my-file_search-store-123'):
print(document_in_store)
file_search_document = client.file_search_stores.documents.get(name='fileSearchStores/my-file_search-store-123/documents/my_doc')
print(file_search_document)
client.file_search_stores.documents.delete(name='fileSearchStores/my-file_search-store-123/documents/my_doc')
JavaScript
const documents = await ai.fileSearchStores.documents.list({
parent: 'fileSearchStores/my-file_search-store-123'
});
for await (const doc of documents) {
console.log(doc);
}
const fileSearchDocument = await ai.fileSearchStores.documents.get({
name: 'fileSearchStores/my-file_search-store-123/documents/my_doc'
});
await ai.fileSearchStores.documents.delete({
name: 'fileSearchStores/my-file_search-store-123/documents/my_doc'
});
REST
curl "https://generativelanguage.googleapis.com/v1beta/fileSearchStores/my-file_search-store-123/documents?key=${GEMINI_API_KEY}"
curl "https://generativelanguage.googleapis.com/v1beta/fileSearchStores/my-file_search-store-123/documents/my_doc?key=${GEMINI_API_KEY}"
curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/fileSearchStores/my-file_search-store-123/documents/my_doc?key=${GEMINI_API_KEY}"
Metadane pliku
Do plików możesz dodawać niestandardowe metadane, aby ułatwić ich filtrowanie lub podać dodatkowy kontekst. Metadane to zbiór par klucz-wartość.
Python
op = client.file_search_stores.import_file(
file_search_store_name=file_search_store.name,
file_name=sample_file.name,
custom_metadata=[
{"key": "author", "string_value": "Robert Graves"},
{"key": "year", "numeric_value": 1934}
]
)
JavaScript
let operation = await ai.fileSearchStores.importFile({
fileSearchStoreName: fileSearchStore.name,
fileName: sampleFile.name,
config: {
customMetadata: [
{ key: "author", stringValue: "Robert Graves" },
{ key: "year", numericValue: 1934 }
]
}
});
Jest to przydatne, gdy masz wiele dokumentów w magazynie narzędzia wyszukiwania plików i chcesz wyszukiwać tylko w ich podzbiorze.
Python
response = client.models.generate_content(
model="gemini-3-flash-preview",
contents="Tell me about the book 'I, Claudius'",
config=types.GenerateContentConfig(
tools=[
types.Tool(
file_search=types.FileSearch(
file_search_store_names=[file_search_store.name],
metadata_filter="author=Robert Graves",
)
)
]
)
)
print(response.text)
JavaScript
const response = await ai.models.generateContent({
model: "gemini-3-flash-preview",
contents: "Tell me about the book 'I, Claudius'",
config: {
tools: [
{
fileSearch: {
fileSearchStoreNames: [fileSearchStore.name],
metadataFilter: 'author="Robert Graves"',
}
}
]
}
});
console.log(response.text);
REST
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent?key=${GEMINI_API_KEY}" \
-H 'Content-Type: application/json' \
-X POST \
-d '{
"contents": [{
"parts":[{"text": "Tell me about the book I, Claudius"}]
}],
"tools": [{
"file_search": {
"file_search_store_names":["'$STORE_NAME'"],
"metadata_filter": "author = \"Robert Graves\""
}
}]
}' 2> /dev/null > response.json
cat response.json
Wskazówki dotyczące implementowania składni filtra listy dla metadata_filter znajdziesz
na stronie google.aip.dev/160
Cytaty
Gdy używasz narzędzia wyszukiwania plików, odpowiedź modelu może zawierać cytaty, które określają, które części przesłanych dokumentów zostały użyte do wygenerowania odpowiedzi. Ułatwia to sprawdzanie faktów i weryfikację.
Informacje o cytatach możesz uzyskać za pomocą atrybutu grounding_metadata odpowiedzi.
Python
print(response.candidates[0].grounding_metadata)
JavaScript
console.log(JSON.stringify(response.candidates?.[0]?.groundingMetadata, null, 2));
Szczegółowe informacje o strukturze metadanych ugruntowania znajdziesz w przykładach w przewodniku po narzędziu wyszukiwania plików lub w sekcji ugruntowania w dokumentacji Ugruntowanie za pomocą wyszukiwarki Google.
Niestandardowe metadane w danych ugruntowania
Jeśli do plików dodano niestandardowe metadane, możesz uzyskać do nich dostęp w metadanych ugruntowania odpowiedzi modelu. Jest to przydatne do przekazywania dodatkowego kontekstu (np. adresów URL, numerów stron lub autorów) z dokumentów źródłowych do logiki aplikacji. Każdy element grounding_chunk w retrieved_context zawiera te niestandardowe metadane.
Python
response = client.models.generate_content(
model="gemini-3-flash-preview",
contents="Tell me about [insert question]",
config=types.GenerateContentConfig(
tools=[
types.Tool(
file_search=types.FileSearch(
file_search_store_names=[file_search_store.name]
)
)
]
)
)
for chunk in response.candidates[0].grounding_metadata.grounding_chunks:
if chunk.retrieved_context:
print(f"Text: {chunk.retrieved_context.text}")
if chunk.retrieved_context.custom_metadata:
for metadata in chunk.retrieved_context.custom_metadata:
print(f"Metadata Key: {metadata.key}")
print(f"Value: {metadata.string_value or metadata.numeric_value}")
JavaScript
const response = await ai.models.generateContent({
model: "gemini-3-flash-preview",
contents: "Tell me about [insert question]",
config: {
tools: [
{
fileSearch: {
fileSearchStoreNames: [fileSearchStore.name]
}
}
]
}
});
const groundingMetadata = response.candidates[0].groundingMetadata;
groundingMetadata.groundingChunks.forEach((chunk) => {
if (chunk.retrievedContext) {
console.log(`Text: ${chunk.retrievedContext.text}`);
if (chunk.retrievedContext.customMetadata) {
chunk.retrievedContext.customMetadata.forEach((metadata) => {
console.log(`Metadata Key: ${metadata.key}`);
console.log(`Value: ${metadata.stringValue || metadata.numericValue}`);
});
}
}
});
REST
{
"candidates": [
{
"content": { ... },
"grounding_metadata": {
"grounding_chunks": [
{
"retrieved_context": {
"text": "...",
"title": "...",
"uri": "...",
"custom_metadata": [
{
"key": "author",
"string_value": "Robert Graves"
},
{
"key": "year",
"numeric_value": 1934
}
]
}
}
],
"grounding_supports": [ ... ]
}
}
]
}
Uporządkowane dane wyjściowe
Począwszy od modeli Gemini 3, możesz łączyć narzędzie wyszukiwania plików z uporządkowanymi danymi wyjściowymi.
Python
from pydantic import BaseModel, Field
class Money(BaseModel):
amount: str = Field(description="The numerical part of the amount.")
currency: str = Field(description="The currency of amount.")
response = client.models.generate_content(
model="gemini-3-flash-preview",
contents="What is the minimum hourly wage in Tokyo right now?",
config=types.GenerateContentConfig(
tools=[
types.Tool(
file_search=types.FileSearch(
file_search_store_names=[file_search_store.name]
)
)
],
response_mime_type="application/json",
response_schema=Money.model_json_schema()
)
)
result = Money.model_validate_json(response.text)
print(result)
JavaScript
import { z } from "zod";
const moneySchema = z.object({
amount: z.string().describe("The numerical part of the amount."),
currency: z.string().describe("The currency of amount."),
});
async function run() {
const response = await ai.models.generateContent({
model: "gemini-3-flash-preview",
contents: "What is the minimum hourly wage in Tokyo right now?",
config: {
tools: [
{
fileSearch: {
fileSearchStoreNames: [file_search_store.name],
},
},
],
responseMimeType: "application/json",
responseJsonSchema: z.toJSONSchema(moneySchema),
},
});
const result = moneySchema.parse(JSON.parse(response.text));
console.log(result);
}
run();
REST
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-X POST \
-d '{
"contents": [{
"parts": [{"text": "What is the minimum hourly wage in Tokyo right now?"}]
}],
"tools": [
{
"fileSearch": {
"fileSearchStoreNames": ["$FILE_SEARCH_STORE_NAME"]
}
}
],
"generationConfig": {
"responseMimeType": "application/json",
"responseJsonSchema": {
"type": "object",
"properties": {
"amount": {"type": "string", "description": "The numerical part of the amount."},
"currency": {"type": "string", "description": "The currency of amount."}
},
"required": ["amount", "currency"]
}
}
}'
Obsługiwane modele
Narzędzie wyszukiwania plików jest obsługiwane przez te modele:
| Model | Narzędzie wyszukiwania plików |
|---|---|
| Gemini 3.1 Pro (wersja testowa) | ✔️ |
| Gemini 3.1 Flash-Lite (wersja testowa) | ✔️ |
| Gemini 3 Flash (wersja testowa) | ✔️ |
| Gemini 2.5 Pro | ✔️ |
| Gemini 2.5 Flash-Lite | ✔️ |
Obsługiwane kombinacje narzędzi
Modele Gemini 3 obsługują łączenie wbudowanych narzędzi (takich jak narzędzie wyszukiwania plików) z narzędziami niestandardowymi (wywoływanie funkcji). Więcej informacji znajdziesz na stronie dotyczącej kombinacji narzędzi.
Obsługiwane typy plików
Narzędzie wyszukiwania plików obsługuje wiele formatów plików wymienionych w tych sekcjach.
Typy plików aplikacji
application/dartapplication/ecmascriptapplication/jsonapplication/ms-javaapplication/mswordapplication/pdfapplication/sqlapplication/typescriptapplication/vnd.curlapplication/vnd.dartapplication/vnd.ibm.secure-containerapplication/vnd.jupyterapplication/vnd.ms-excelapplication/vnd.oasis.opendocument.textapplication/vnd.openxmlformats-officedocument.presentationml.presentationapplication/vnd.openxmlformats-officedocument.spreadsheetml.sheetapplication/vnd.openxmlformats-officedocument.wordprocessingml.documentapplication/vnd.openxmlformats-officedocument.wordprocessingml.templateapplication/x-cshapplication/x-hwpapplication/x-hwp-v5application/x-latexapplication/x-phpapplication/x-powershellapplication/x-shapplication/x-shellscriptapplication/x-texapplication/x-zshapplication/xmlapplication/zip
Typy plików tekstowych
text/1d-interleaved-parityfectext/REDtext/SGMLtext/cache-manifesttext/calendartext/cqltext/cql-extensiontext/cql-identifiertext/csstext/csvtext/csv-schematext/dnstext/encaprtptext/enrichedtext/exampletext/fhirpathtext/flexfectext/fwdredtext/gff3text/grammar-ref-listtext/hl7v2text/htmltext/javascripttext/jcr-cndtext/jsxtext/markdowntext/mizartext/n3text/parameterstext/parityfectext/phptext/plaintext/provenance-notationtext/prs.fallenstein.rsttext/prs.lines.tagtext/prs.prop.logictext/raptorfectext/rfc822-headerstext/rtftext/rtp-enc-aescm128text/rtploopbacktext/rtxtext/sgmltext/shaclctext/shextext/spdxtext/stringstext/t140text/tab-separated-valuestext/texmacstext/trofftext/tsvtext/tsxtext/turtletext/ulpfectext/uri-listtext/vcardtext/vnd.DMClientScripttext/vnd.IPTC.NITFtext/vnd.IPTC.NewsMLtext/vnd.atext/vnd.abctext/vnd.ascii-arttext/vnd.curltext/vnd.debian.copyrighttext/vnd.dvb.subtitletext/vnd.esmertec.theme-descriptortext/vnd.exchangeabletext/vnd.familysearch.gedcomtext/vnd.ficlab.flttext/vnd.flytext/vnd.fmi.flexstortext/vnd.gmltext/vnd.graphviztext/vnd.hanstext/vnd.hgltext/vnd.in3d.3dmltext/vnd.in3d.spottext/vnd.latex-ztext/vnd.motorola.reflextext/vnd.ms-mediapackagetext/vnd.net2phone.commcenter.commandtext/vnd.radisys.msml-basic-layouttext/vnd.senx.warpscripttext/vnd.sositext/vnd.sun.j2me.app-descriptortext/vnd.trolltech.linguisttext/vnd.wap.sitext/vnd.wap.sltext/vnd.wap.wmltext/vnd.wap.wmlscripttext/vtttext/wgsltext/x-asmtext/x-bibtextext/x-bootext/x-ctext/x-c++hdrtext/x-c++srctext/x-cassandratext/x-chdrtext/x-coffeescripttext/x-componenttext/x-cshtext/x-csharptext/x-csrctext/x-cudatext/x-dtext/x-difftext/x-dsrctext/x-emacs-lisptext/x-erlangtext/x-gff3text/x-gotext/x-haskelltext/x-javatext/x-java-propertiestext/x-java-sourcetext/x-kotlintext/x-lilypondtext/x-lisptext/x-literate-haskelltext/x-luatext/x-moctext/x-objcsrctext/x-pascaltext/x-pcs-gcdtext/x-perltext/x-perl-scripttext/x-pythontext/x-python-scripttext/x-r-markdowntext/x-rsrctext/x-rsttext/x-ruby-scripttext/x-rusttext/x-sasstext/x-scalatext/x-schemetext/x-script.pythontext/x-scsstext/x-setexttext/x-sfvtext/x-shtext/x-siestatext/x-sostext/x-sqltext/x-swifttext/x-tcltext/x-textext/x-vbasictext/x-vcalendartext/xmltext/xml-dtdtext/xml-external-parsed-entitytext/yaml
Ograniczenia
- Live API: Wyszukiwanie plików nie jest obsługiwane w Live API.
- Niezgodność narzędzi: wyszukiwania plików nie można obecnie łączyć z innymi narzędziami takimi jak powiązanie ze źródłem informacji przy użyciu wyszukiwarki Google, kontekst adresu URL itp.
Ograniczenia liczby żądań
Aby zapewnić stabilność usługi, interfejs File Search API ma te ograniczenia:
- Maksymalny rozmiar pliku / limit na dokument: 100 MB.
- Łączny rozmiar magazynów narzędzia wyszukiwania plików w projekcie (w zależności od poziomu użytkownika):
- Bezpłatny: 1 GB.
- Poziom 1: 10 GB.
- Poziom 2: 100 GB.
- Poziom 3: 1 TB.
- Zalecenie: aby zapewnić optymalne opóźnienia wyszukiwania, ogranicz rozmiar każdego magazynu narzędzia wyszukiwania plików do mniej niż 20 GB.
Ceny
- Opłaty za wektory dystrybucyjne są naliczane deweloperom w momencie indeksowania na podstawie obowiązujących cen wektorów dystrybucyjnych (0,15 USD za 1 mln tokenów).
- Przechowywanie jest bezpłatne.
- Wektory dystrybucyjne w czasie wykonywania zapytań są bezpłatne.
- Tokeny pobranych dokumentów są naliczane jako zwykłe tokeny kontekstu.
Co dalej?
- Zapoznaj się z dokumentacją API dotyczącą magazynów narzędzia wyszukiwania plików i dokumentów narzędzia wyszukiwania plików.