Provoni modelin e ri Veo 3.1 Lite me shpejtësi të lartë dhe kosto-efektiv për gjenerimin e videove në shkallë të gjerë.

Kjo faqe është përkthyer nga Cloud Translation API.

Kërkimi i skedarëve

The Gemini API enables Retrieval Augmented Generation ("RAG") through the File Search tool. File Search imports, chunks, and indexes your data to enable fast retrieval of relevant information based on a provided prompt. This information is then used as context for the model, allowing the model to provide more accurate and relevant answers.

Për ta bërë Kërkimin e Skedarëve të thjeshtë dhe të përballueshëm për zhvilluesit, ne po e bëjmë ruajtjen e skedarëve dhe gjenerimin e ngulitjeve në kohën e pyetjes falas. Ju paguani vetëm për krijimin e ngulitjeve kur indeksoni për herë të parë skedarët tuaj (me koston përkatëse të modelit të ngulitjeve) dhe koston normale të tokenëve hyrës/dalës të modelit Gemini. Kjo paradigmë e re faturimi e bën Mjetin e Kërkimit të Skedarëve më të lehtë dhe më kosto-efektiv për t'u ndërtuar dhe për t'u shkallëzuar.

Ngarkoje direkt në dyqanin e Kërkimit të Skedarëve

Ky shembull tregon se si të ngarkoni direkt një skedar në dyqanin e kërkimit të skedarëve :

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();

Kontrolloni referencën API për uploadToFileSearchStore për më shumë informacion.

Importimi i skedarëve

Si alternativë, mund të ngarkoni një skedar ekzistues dhe ta importoni atë në dyqanin tuaj të kërkimit të skedarëve :

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();

Kontrolloni referencën API për importFile për më shumë informacion.

Konfigurimi i ndarjes në grupe

When you import a file into a File Search store, it's automatically broken down into chunks, embedded, indexed, and uploaded to your File Search store. If you need more control over the chunking strategy, you can specify a chunking_config setting to set a maximum number of tokens per chunk and maximum number of overlapping tokens.

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.");

Për të përdorur dyqanin tuaj të Kërkimit të Skedarëve, kalojeni atë si një mjet te metoda generateContent , siç tregohet në shembujt e Ngarkimit dhe Importit .

Si funksionon

File Search uses a technique called semantic search to find information relevant to the user prompt. Unlike standard keyword-based search, semantic search understands the meaning and context of your query.

Kur importoni një skedar, ai konvertohet në përfaqësime numerike të quajtura ngulitje , të cilat kapin kuptimin semantik të tekstit. Këto ngulitje ruhen në një bazë të dhënash të specializuar të Kërkimit të Skedarëve. Kur bëni një pyetje, edhe ajo konvertohet në një ngulitje. Pastaj sistemi kryen një Kërkim Skedarësh për të gjetur pjesët më të ngjashme dhe më relevante të dokumentit nga dyqani i Kërkimit të Skedarëve.

There is no Time To Live (TTL) for embeddings and files; they persist until manually deleted, or when the model is deprecated.

Ja një përshkrim i hollësishëm i procesit për përdorimin e File Search uploadToFileSearchStore API:

Krijo një depo të Kërkimit të Skedarëve : Një depo e Kërkimit të Skedarëve përmban të dhënat e përpunuara nga skedarët tuaj. Është kontejneri i përhershëm për ngulitje mbi të cilin do të veprojë kërkimi semantik.
Ngarko një skedar dhe importo në një depo të Kërkimit të Skedarëve : Ngarko njëkohësisht një skedar dhe importo rezultatet në depon tënd të Kërkimit të Skedarëve. Kjo krijon një objekt të përkohshëm File , i cili është një referencë për dokumentin tënd të papërpunuar. Këto të dhëna më pas ndahen në copa, konvertohen në ngulitje të Kërkimit të Skedarëve dhe indeksohen. Objekti File fshihet pas 48 orësh, ndërsa të dhënat e importuara në depon e Kërkimit të Skedarëve do të ruhen për një kohë të pacaktuar derisa të zgjedhësh t'i fshish.
Query with File Search : Finally, you use the FileSearch tool in a generateContent call. In the tool configuration, you specify a FileSearchRetrievalResource , which points to the FileSearchStore you want to search. This tells the model to perform a semantic search on that specific File Search store to find relevant information to ground its response.

Procesi i indeksimit dhe pyetjeve të Kërkimit të Skedarëve

In this diagram, the dotted line from from Documents to Embedding model (using gemini-embedding-001 ) represents the uploadToFileSearchStore API (bypassing File storage ). Otherwise, using the Files API to separately create and then import files moves the indexing process from Documents to File storage and then to Embedding model .

Dyqanet e Kërkimit të Skedarëve

Një depo File Search është një kontejner për ngulitje dokumentesh. Ndërsa skedarët e papërpunuar të ngarkuar përmes File API fshihen pas 48 orësh, të dhënat e importuara në një depo File Search ruhen për një kohë të pacaktuar derisa t'i fshini manualisht. Mund të krijoni disa depo File Search për të organizuar dokumentet tuaja. FileSearchStore API ju lejon të krijoni, listoni, merrni dhe fshini për të menaxhuar depot e kërkimit të skedarëve. Emrat e depove File Search janë të shtrira globalisht.

Ja disa shembuj se si të menaxhoni dyqanet tuaja të Kërkimit të Skedarëve:

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 }
});

PUSHTIM

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}"

Dokumentet e kërkimit të skedarëve

You can manage individual documents in your file stores with the File Search Documents API to list each document in a file search store, get information about a document, and delete a document by name.

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'
});

PUSHTIM

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}"

Metadatat e skedarit

Mund të shtoni meta të dhëna të personalizuara në skedarët tuaj për t'i ndihmuar në filtrimin e tyre ose për të ofruar kontekst shtesë. Meta të dhënat janë një grup çiftesh çelës-vlerë.

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 }
    ]
  }
});

Kjo është e dobishme kur keni dokumente të shumta në një dyqan të Kërkimit të Skedarëve dhe dëshironi të kërkoni vetëm në një nëngrup të tyre.

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);

PUSHTIM

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

Udhëzime mbi zbatimin e sintaksës së filtrit të listës për metadata_filter mund të gjenden në google.aip.dev/160

Citime

When you use File Search, the model's response may include citations that specify which parts of your uploaded documents were used to generate the answer. This helps with fact-checking and verification.

Mund të qaseni në informacionin e citimeve përmes atributit grounding_metadata të përgjigjes.

Python

print(response.candidates[0].grounding_metadata)

JavaScript

console.log(JSON.stringify(response.candidates?.[0]?.groundingMetadata, null, 2));

Për informacion të detajuar mbi strukturën e meta të dhënave të tokëzimit, shihni shembujt në librin e gatimit File Search ose seksionin e tokëzimit të dokumenteve Grounding with Google Search .

Metadata të personalizuara në të dhënat e tokëzimit

If you have added custom metadata to your files, you can access it in the grounding metadata of the model's response. This is useful for passing additional context (like URLs, page numbers, or authors) from your source documents to your application logic. Each grounding_chunk in the retrieved_context contains this custom metadata.

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}`);
      });
    }
  }
});

PUSHTIM

{
  "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": [ ... ]
      }
    }
  ]
}

Prodhim i strukturuar

Duke filluar me modelet Gemini 3, mund të kombinoni mjetin e kërkimit të skedarëve me rezultatet e strukturuara .

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();

PUSHTIM

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"]
        }
    }
  }'

Modelet e mbështetura

Modelet e mëposhtme mbështesin Kërkimin e Skedarëve:

Model	Kërkimi i skedarëve
Pamje paraprake e Gemini 3.1 Pro	✔️
Pamje paraprake e Gemini 3.1 Flash-Lite	✔️
Pamje paraprake e shpejtë e Gemini 3	✔️
Gemini 2.5 Pro	✔️
Gemini 2.5 Flash-Lite	✔️

Kombinimet e mjeteve të mbështetura

Modelet Gemini 3 mbështesin kombinimin e mjeteve të integruara (si Kërkimi i Skedarëve) me mjete të personalizuara (thirrja e funksioneve). Mësoni më shumë në faqen e kombinimeve të mjeteve .

Llojet e skedarëve të mbështetur

Kërkimi i skedarëve mbështet një gamë të gjerë formatesh skedarësh, të listuara në seksionet vijuese.

Llojet e skedarëve të aplikacionit

application/dart
application/ecmascript
application/json
application/ms-java
application/msword
application/pdf
application/sql
application/typescript
application/vnd.curl
application/vnd.dart
application/vnd.ibm.secure-container
application/vnd.jupyter
application/vnd.ms-excel
application/vnd.oasis.opendocument.text
application/vnd.openxmlformats-officedocument.presentationml.presentation
application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
application/vnd.openxmlformats-officedocument.wordprocessingml.document
application/vnd.openxmlformats-officedocument.wordprocessingml.template
application/x-csh
application/x-hwp
application/x-hwp-v5
application/x-latex
application/x-php
application/x-powershell
application/x-sh
application/x-shellscript
application/x-tex
application/x-zsh
application/xml
application/zip

Llojet e skedarëve të tekstit

text/1d-interleaved-parityfec
text/RED
text/SGML
text/cache-manifest
text/calendar
text/cql
text/cql-extension
text/cql-identifier
text/css
text/csv
text/csv-schema
text/dns
text/encaprtp
text/enriched
text/example
text/fhirpath
text/flexfec
text/fwdred
text/gff3
text/grammar-ref-list
text/hl7v2
text/html
text/javascript
text/jcr-cnd
text/jsx
text/markdown
text/mizar
text/n3
text/parameters
text/parityfec
text/php
text/plain
text/provenance-notation
text/prs.fallenstein.rst
text/prs.lines.tag
text/prs.prop.logic
text/raptorfec
text/rfc822-headers
text/rtf
text/rtp-enc-aescm128
text/rtploopback
text/rtx
text/sgml
text/shaclc
text/shex
text/spdx
text/strings
text/t140
text/tab-separated-values
text/texmacs
text/troff
text/tsv
text/tsx
text/turtle
text/ulpfec
text/uri-list
text/vcard
text/vnd.DMClientScript
text/vnd.IPTC.NITF
text/vnd.IPTC.NewsML
text/vnd.a
text/vnd.abc
text/vnd.ascii-art
text/vnd.curl
text/vnd.debian.copyright
text/vnd.dvb.subtitle
text/vnd.esmertec.theme-descriptor
text/vnd.exchangeable
text/vnd.familysearch.gedcom
text/vnd.ficlab.flt
text/vnd.fly
text/vnd.fmi.flexstor
text/vnd.gml
text/vnd.graphviz
text/vnd.hans
text/vnd.hgl
text/vnd.in3d.3dml
text/vnd.in3d.spot
text/vnd.latex-z
text/vnd.motorola.reflex
text/vnd.ms-mediapackage
text/vnd.net2phone.commcenter.command
text/vnd.radisys.msml-basic-layout
text/vnd.senx.warpscript
text/vnd.sosi
text/vnd.sun.j2me.app-descriptor
text/vnd.trolltech.linguist
text/vnd.wap.si
text/vnd.wap.sl
text/vnd.wap.wml
text/vnd.wap.wmlscript
text/vtt
text/wgsl
text/x-asm
text/x-bibtex
text/x-boo
text/xc
text/x-c++hdr
text/x-c++src
text/x-cassandra
text/x-chdr
text/x-coffeescript
text/x-component
text/x-csh
text/x-csharp
text/x-csrc
text/x-cuda
text/xd
text/x-diff
text/x-dsrc
text/x-emacs-lisp
text/x-erlang
text/x-gff3
text/x-go
text/x-haskell
text/x-java
text/x-java-properties
text/x-java-source
text/x-kotlin
text/x-lilypond
text/x-lisp
text/x-literate-haskell
text/x-lua
text/x-moc
text/x-objcsrc
text/x-pascal
text/x-pcs-gcd
text/x-perl
text/x-perl-script
text/x-python
text/x-python-script
text/xr-markdown
text/x-rsrc
text/x-rst
text/x-ruby-script
text/x-rust
text/x-sass
text/x-scala
text/x-scheme
text/x-script.python
text/x-scss
text/x-setext
text/x-sfv
text/x-sh
text/x-siesta
text/x-sos
text/x-sql
text/x-swift
text/x-tcl
text/x-tex
text/x-vbasic
text/x-vcalendar
text/xml
text/xml-dtd
text/xml-external-parsed-entity
text/yaml

Kufizime

API Live: Kërkimi i skedarëve nuk mbështetet në API-n Live .
Papajtueshmëria e mjeteve: Kërkimi i skedarëve nuk mund të kombinohet me mjete të tjera si Grounding with Google Search , URL Context , etj., për momentin.

Limitet e tarifave

The File Search API has the following limits to enforce service stability:

Madhësia maksimale e skedarit / limiti për dokument : 100 MB
Madhësia totale e ruajtjeve të Kërkimit të Skedarëve të projektit (bazuar në nivelin e përdoruesit):
- Falas : 1 GB
- Niveli 1 : 10 GB
- Niveli 2 : 100 GB
- Niveli 3 : 1 TB
Rekomandim : Kufizoni madhësinë e secilës hapësirë ruajtjeje të Kërkimit të Skedarëve në nën 20 GB për të siguruar vonesa optimale të rikuperimit.

Çmimet

Zhvilluesve u faturohen ngulitje në kohën e indeksimit bazuar në çmimet ekzistuese të ngulitjeve (0,15 dollarë për 1 milion tokenë).
Magazinimi është falas.
Integrimet në kohën e pyetjeve janë pa pagesë.
Tokenët e dokumentit të marrë tarifohen si tokenë të rregullt konteksti .

Çfarë vjen më pas

Vizitoni referencën API për Depozitat e Kërkimit të Skedarëve dhe Dokumentet e Kërkimit të Skedarëve.