Using files

API-ja Gemini mbështet ngarkimin e skedarëve media veçmas nga hyrja e kërkesës, duke lejuar që media juaj të ripërdoret në kërkesa dhe kërkesa të shumëfishta. Për më shumë detaje, shikoni udhëzuesin "Nxitja me media" .

Metoda: media.upload

Krijon një File .

Pika e Fundit

  • URI i ngarkimit, për kërkesat e ngarkimit të medias:
    • posto https: / /generativelanguage.googleapis.com /upload /v1beta /files
  • URI i meta të dhënave, për kërkesat vetëm për meta të dhëna:
    • posto https: / /generativelanguage.googleapis.com /v1beta /files

    Trupi i kërkesës

    Trupi i kërkesës përmban të dhëna me strukturën e mëposhtme:

    Fushat
    objekt file object ( File )

    Opsionale. Meta të dhëna për skedarin që do të krijohet.

    Shembull kërkese

    Imazh

    Python 

    from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "Cajun_instruments.jpg")
print(f"{myfile=}")

result = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[
        myfile,
        "\n\n",
        "Can you tell me about the instruments in this photo?",
    ],
)
print(f"{result.text=}")
    files.py

    Node.js 

    // Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const myfile = await ai.files.upload({
  file: path.join(media, "Cajun_instruments.jpg"),
  config: { mimeType: "image/jpeg" },
});
console.log("Uploaded file:", myfile);

const result = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: createUserContent([
    createPartFromUri(myfile.uri, myfile.mimeType),
    "\n\n",
    "Can you tell me about the instruments in this photo?",
  ]),
});
console.log("result.text=", result.text);
    files.js

    Shko 

    ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "Cajun_instruments.jpg"), 
	&genai.UploadFileConfig{
		MIMEType : "image/jpeg",
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("myfile=%+v\n", myfile)

parts := []*genai.Part{
	genai.NewPartFromURI(myfile.URI, myfile.MIMEType),
	genai.NewPartFromText("\n\n"),
	genai.NewPartFromText("Can you tell me about the instruments in this photo?"),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
text := response.Text()
fmt.Printf("result.text=%s\n", text)
    files.go

    Guaskë 

    MIME_TYPE=$(file -b --mime-type "${IMG_PATH_2}")
NUM_BYTES=$(wc -c < "${IMG_PATH_2}")
DISPLAY_NAME=TEXT

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${IMG_PATH_2}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Can you tell me about the instruments in this photo?"},
          {"file_data":
            {"mime_type": "image/jpeg", 
            "file_uri": '$file_uri'}
        }]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json
    files.sh

    Audio

    Python 

    from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "sample.mp3")
print(f"{myfile=}")

result = client.models.generate_content(
    model="gemini-2.0-flash", contents=[myfile, "Describe this audio clip"]
)
print(f"{result.text=}")
    files.py

    Node.js 

    // Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const myfile = await ai.files.upload({
  file: path.join(media, "sample.mp3"),
  config: { mimeType: "audio/mpeg" },
});
console.log("Uploaded file:", myfile);

const result = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: createUserContent([
    createPartFromUri(myfile.uri, myfile.mimeType),
    "Describe this audio clip",
  ]),
});
console.log("result.text=", result.text);
    files.js

    Shko 

    ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "sample.mp3"), 
	&genai.UploadFileConfig{
		MIMEType : "audio/mpeg",
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("myfile=%+v\n", myfile)

parts := []*genai.Part{
	genai.NewPartFromURI(myfile.URI, myfile.MIMEType),
	genai.NewPartFromText("Describe this audio clip"),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
text := response.Text()
fmt.Printf("result.text=%s\n", text)
    files.go

    Guaskë 

    MIME_TYPE=$(file -b --mime-type "${AUDIO_PATH}")
NUM_BYTES=$(wc -c < "${AUDIO_PATH}")
DISPLAY_NAME=AUDIO

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${AUDIO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Describe this audio clip"},
          {"file_data":{"mime_type": "audio/mp3", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json
    files.sh

    Tekst

    Python 

    from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "poem.txt")
print(f"{myfile=}")

result = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[myfile, "\n\n", "Can you add a few more lines to this poem?"],
)
print(f"{result.text=}")
    files.py

    Node.js 

    // Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const myfile = await ai.files.upload({
  file: path.join(media, "poem.txt"),
});
console.log("Uploaded file:", myfile);

const result = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: createUserContent([
    createPartFromUri(myfile.uri, myfile.mimeType),
    "\n\n",
    "Can you add a few more lines to this poem?",
  ]),
});
console.log("result.text=", result.text);
    files.js

    Shko 

    ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}

myfile, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "poem.txt"), 
	&genai.UploadFileConfig{
		MIMEType : "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("myfile=%+v\n", myfile)

parts := []*genai.Part{
	genai.NewPartFromURI(myfile.URI, myfile.MIMEType),
	genai.NewPartFromText("\n\n"),
	genai.NewPartFromText("Can you add a few more lines to this poem?"),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
text := response.Text()
fmt.Printf("result.text=%s\n", text)
    files.go

    Guaskë 

    MIME_TYPE=$(file -b --mime-type "${TEXT_PATH}")
NUM_BYTES=$(wc -c < "${TEXT_PATH}")
DISPLAY_NAME=TEXT

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${TEXT_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Can you add a few more lines to this poem?"},
          {"file_data":{"mime_type": "text/plain", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

name=$(jq ".file.name" file_info.json)
# Get the file of interest to check state
curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
# Print some information about the file you got
name=$(jq ".file.name" file_info.json)
echo name=$name
file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

curl --request "DELETE" https://generativelanguage.googleapis.com/v1beta/files/$name?key=$GEMINI_API_KEY

    files.sh

    Video

    Python 

    from google import genai
import time

client = genai.Client()
# Video clip (CC BY 3.0) from https://peach.blender.org/download/
myfile = client.files.upload(file=media / "Big_Buck_Bunny.mp4")
print(f"{myfile=}")

# Poll until the video file is completely processed (state becomes ACTIVE).
while not myfile.state or myfile.state.name != "ACTIVE":
    print("Processing video...")
    print("File state:", myfile.state)
    time.sleep(5)
    myfile = client.files.get(name=myfile.name)

result = client.models.generate_content(
    model="gemini-2.0-flash", contents=[myfile, "Describe this video clip"]
)
print(f"{result.text=}")
    files.py

    Node.js 

    // Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
let myfile = await ai.files.upload({
  file: path.join(media, "Big_Buck_Bunny.mp4"),
  config: { mimeType: "video/mp4" },
});
console.log("Uploaded video file:", myfile);

// Poll until the video file is completely processed (state becomes ACTIVE).
while (!myfile.state || myfile.state.toString() !== "ACTIVE") {
  console.log("Processing video...");
  console.log("File state: ", myfile.state);
  await sleep(5000);
  myfile = await ai.files.get({ name: myfile.name });
}

const result = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: createUserContent([
    createPartFromUri(myfile.uri, myfile.mimeType),
    "Describe this video clip",
  ]),
});
console.log("result.text=", result.text);
    files.js

    Shko 

    ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "Big_Buck_Bunny.mp4"), 
	&genai.UploadFileConfig{
		MIMEType : "video/mp4",
	},
)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("myfile=%+v\n", myfile)

// Poll until the video file is completely processed (state becomes ACTIVE).
for myfile.State == genai.FileStateUnspecified || myfile.State != genai.FileStateActive {
	fmt.Println("Processing video...")
	fmt.Println("File state:", myfile.State)
	time.Sleep(5 * time.Second)

	myfile, err = client.Files.Get(ctx, myfile.Name, nil)
	if err != nil {
		log.Fatal(err)
	}
}

parts := []*genai.Part{
	genai.NewPartFromURI(myfile.URI, myfile.MIMEType),
	genai.NewPartFromText("Describe this video clip"),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
text := response.Text()
fmt.Printf("result.text=%s\n", text)
    files.go

    Guaskë 

    MIME_TYPE=$(file -b --mime-type "${VIDEO_PATH}")
NUM_BYTES=$(wc -c < "${VIDEO_PATH}")
DISPLAY_NAME=VIDEO_PATH

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${VIDEO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

state=$(jq ".file.state" file_info.json)
echo state=$state

# Ensure the state of the video is 'ACTIVE'
while [[ "($state)" = *"PROCESSING"* ]];
do
  echo "Processing video..."
  sleep 5
  # Get the file of interest to check state
  curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
  state=$(jq ".file.state" file_info.json)
done

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Describe this video clip"},
          {"file_data":{"mime_type": "video/mp4", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json
    files.sh

    PDF

    Python 

    from google import genai

client = genai.Client()
sample_pdf = client.files.upload(file=media / "test.pdf")
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=["Give me a summary of this pdf file.", sample_pdf],
)
print(response.text)
    files.py

    Shko 

    ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
samplePdf, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "test.pdf"),
	&genai.UploadFileConfig{
		MIMEType: "application/pdf",
	},
)
if err != nil {
	log.Fatal(err)
}

parts := []*genai.Part{
	genai.NewPartFromText("Give me a summary of this pdf file."),
	genai.NewPartFromURI(samplePdf.URI, samplePdf.MIMEType),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
if err != nil {
	log.Fatal(err)
}
text := response.Text()
fmt.Println(text)
    files.go

    Trupi i përgjigjes

    Përgjigje për media.upload .

    Nëse është i suksesshëm, trupi i përgjigjes përmban të dhëna me strukturën e mëposhtme:

    Fushat
    objekt file object ( File )

    Meta të dhënat për skedarin e krijuar.

    Përfaqësimi JSON 
    {
  "file": {
    object (File)
  }
}

    Metoda: files.get

    Merr meta të dhënat për File e dhënë.

    Pika e Fundit

    merrni https: / /generativelanguage.googleapis.com /v1beta /{name=files /*}

    Parametrat e shtegut

    string name

    E detyrueshme. Emri i File që do të merret. Shembull: files/abc-123 Merr formën files/{file} .

    Trupi i kërkesës

    Trupi i kërkesës duhet të jetë bosh.

    Shembull kërkese

    Python 

    from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "poem.txt")
file_name = myfile.name
print(file_name)  # "files/*"

myfile = client.files.get(name=file_name)
print(myfile)
    files.py

    Node.js 

    // Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const myfile = await ai.files.upload({
  file: path.join(media, "poem.txt"),
});
const fileName = myfile.name;
console.log(fileName);

const fetchedFile = await ai.files.get({ name: fileName });
console.log(fetchedFile);
    files.js

    Shko 

    ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "poem.txt"), 
	&genai.UploadFileConfig{
		MIMEType: "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
fileName := myfile.Name
fmt.Println(fileName)
file, err := client.Files.Get(ctx, fileName, nil)
if err != nil {
	log.Fatal(err)
}
fmt.Println(file)
    files.go

    Guaskë 

    name=$(jq ".file.name" file_info.json)
# Get the file of interest to check state
curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
# Print some information about the file you got
name=$(jq ".file.name" file_info.json)
echo name=$name
file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri
    files.sh

    Trupi i përgjigjes

    Nëse është e suksesshme, trupi i përgjigjes përmban një instancë të File .

    Metoda: files.list

    Liston metadatat për File në pronësi të projektit kërkues.

    Pika e Fundit

    merrni https: / /generativelanguage.googleapis.com /v1beta /files

    Parametrat e pyetjes

    pageSize integer

    Opsionale. Numri maksimal i File për t'u kthyer për faqe. Nëse nuk specifikohet, vlera parazgjedhur është 10. Madhësia maksimale pageSize është 100.

    vargu i pageToken string

    Opsionale. Një shenjë faqeje nga një thirrje e mëparshme files.list .

    Trupi i kërkesës

    Trupi i kërkesës duhet të jetë bosh.

    Shembull kërkese

    Python 

    from google import genai

client = genai.Client()
print("My files:")
for f in client.files.list():
    print("  ", f.name)
    files.py

    Node.js 

    // Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
console.log("My files:");
// Using the pager style to list files
const pager = await ai.files.list({ config: { pageSize: 10 } });
let page = pager.page;
const names = [];
while (true) {
  for (const f of page) {
    console.log("  ", f.name);
    names.push(f.name);
  }
  if (!pager.hasNextPage()) break;
  page = await pager.nextPage();
}
    files.js

    Shko 

    ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
fmt.Println("My files:")
page, err := client.Files.List(ctx, nil)
if err != nil {
	log.Fatal(err)
}
for _, f := range page.Items {
	fmt.Println("  ", f.Name)
}
    files.go

    Guaskë 

    echo "My files: "

curl "https://generativelanguage.googleapis.com/v1beta/files?key=$GEMINI_API_KEY"
    files.sh

    Trupi i përgjigjes

    Përgjigje për files.list .

    Nëse është i suksesshëm, trupi i përgjigjes përmban të dhëna me strukturën e mëposhtme:

    Fushat
    files[] object ( File )

    Lista e File s.

    string nextPageToken

    Një token që mund të dërgohet si pageToken në një thirrje pasuese files.list .

    Përfaqësimi JSON 
    {
  "files": [
    {
      object (File)
    }
  ],
  "nextPageToken": string
}

    Metoda: files.delete

    Fshin File .

    Pika e Fundit

    fshi https: / /generativelanguage.googleapis.com /v1beta /{name=files /*}

    Parametrat e shtegut

    string name

    E detyrueshme. Emri i File që do të fshihet. Shembull: files/abc-123 Merr formën files/{file} .

    Trupi i kërkesës

    Trupi i kërkesës duhet të jetë bosh.

    Shembull kërkese

    Python 

    from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "poem.txt")

client.files.delete(name=myfile.name)

try:
    result = client.models.generate_content(
        model="gemini-2.0-flash", contents=[myfile, "Describe this file."]
    )
    print(result)
except genai.errors.ClientError:
    pass
    files.py

    Node.js 

    // The Gen AI SDK for TypeScript and JavaScript is in preview.
// Some features have not been implemented.
    README.md

    Shko 

    ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "poem.txt"), 
	&genai.UploadFileConfig{
		MIMEType: "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
// Delete the file.
_, err = client.Files.Delete(ctx, myfile.Name, nil)
if err != nil {
	log.Fatal(err)
}
// Attempt to use the deleted file.
parts := []*genai.Part{
	genai.NewPartFromURI(myfile.URI, myfile.MIMEType,),
	genai.NewPartFromText("Describe this file."),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

_, err = client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
// Expect an error when using a deleted file.
if err != nil {
	return nil
}
return fmt.Errorf("expected an error when using deleted file")
    files.go

    Guaskë 

    curl --request "DELETE" https://generativelanguage.googleapis.com/v1beta/files/$name?key=$GEMINI_API_KEY
    files.sh

    Trupi i përgjigjes

    Nëse është i suksesshëm, trupi i përgjigjes është një objekt JSON bosh.

    Metoda: files.register

    Regjistron skedarë të Google Cloud Storage me FileService. Përdoruesi pritet të ofrojë URI-të e Google Cloud Storage dhe do të marrë një burim Skedari për secilën URI në këmbim. Vini re se skedarët nuk kopjohen, por vetëm regjistrohen me File API. Nëse një skedar nuk arrin të regjistrohet, e gjithë kërkesa dështon.

    Pika e Fundit

    posto https: / /generativelanguage.googleapis.com /v1beta /files:register

    Trupi i kërkesës

    Trupi i kërkesës përmban të dhëna me strukturën e mëposhtme:

    Fushat
    string uris[]

    E detyrueshme. URI-të e Google Cloud Storage që duhen regjistruar. Shembull: gs://bucket/object .

    Trupi i përgjigjes

    Përgjigje për files.register .

    Nëse është i suksesshëm, trupi i përgjigjes përmban të dhëna me strukturën e mëposhtme:

    Fushat
    files[] object ( File )

    Skedarët e regjistruar që do të përdoren kur thirret GenerateContent.

    Përfaqësimi JSON 
    {
  "files": [
    {
      object (File)
    }
  ]
}

    Burimi REST: skedarë

    Burimi: Skedar

    Një skedar i ngarkuar në API. ID-ja tjetër: 15

    Fushat
    string name

    I pandryshueshëm. Identifikues. Emri i burimit File . ID-ja (emri duke përjashtuar parashtesën "files/") mund të përmbajë deri në 40 karaktere që janë shkronja të vogla alfanumerike ose viza (-). ID-ja nuk mund të fillojë ose të mbarojë me vizë. Nëse emri është bosh gjatë krijimit, do të gjenerohet një emër unik. Shembull: files/123-456

    string displayName

    Opsionale. Emri i shfaqur i lexueshëm nga njeriu për File . Emri i shfaqur nuk duhet të jetë më shumë se 512 karaktere i gjatë, duke përfshirë hapësirat. Shembull: "Imazhi i Mirëseardhjes"

    string mimeType

    Vetëm rezultat. Lloji MIME i skedarit.

    vargu sizeBytes string ( int64 format)

    Vetëm rezultati. Madhësia e skedarit në bajt.

    createTime string ( Timestamp format)

    Vetëm rezultati. Vula kohore e kohës kur u krijua File .

    Përdor RFC 3339, ku rezultati i gjeneruar do të jetë gjithmonë i normalizuar sipas Z-së dhe do të përdorë 0, 3, 6 ose 9 shifra thyesore. Pranohen edhe zhvendosje të tjera përveç "Z". Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

    vargu updateTime string ( Timestamp format)

    Vetëm rezultati. Vula kohore e përditësimit të fundit të File .

    Përdor RFC 3339, ku rezultati i gjeneruar do të jetë gjithmonë i normalizuar sipas Z-së dhe do të përdorë 0, 3, 6 ose 9 shifra thyesore. Pranohen edhe zhvendosje të tjera përveç "Z". Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

    Vargu i kohës expirationTime string ( Timestamp format)

    Vetëm rezultati. Vula kohore se kur do të fshihet File . Caktohet vetëm nëse File është planifikuar të skadojë.

    Përdor RFC 3339, ku rezultati i gjeneruar do të jetë gjithmonë i normalizuar sipas Z-së dhe do të përdorë 0, 3, 6 ose 9 shifra thyesore. Pranohen edhe zhvendosje të tjera përveç "Z". Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

    sha256Hash string ( bytes format)

    Vetëm dalje. Hash SHA-256 i bajteve të ngarkuara.

    Një varg i koduar me base64.

    uri string

    Vetëm rezultati. URI-ja e File .

    string downloadUri së

    Vetëm rezultati. URI-ja e shkarkimit të File .

    numërimi state enum ( State )

    Vetëm rezultati. Gjendja e përpunimit të skedarit.

    enum source enum ( Source )

    Burimi i Dosjes.

    objekt error object ( Status )

    Vetëm rezultat. Statusi i gabimit nëse përpunimi i skedarit dështoi.

    Union type metadata
    Meta të dhënat për Skedarin. metadata mund të jenë vetëm një nga të mëposhtmet:
    objekti videoMetadata object ( VideoFileMetadata )

    Vetëm rezultate. Meta të dhëna për një video.

    Përfaqësimi JSON 
    {
  "name": string,
  "displayName": string,
  "mimeType": string,
  "sizeBytes": string,
  "createTime": string,
  "updateTime": string,
  "expirationTime": string,
  "sha256Hash": string,
  "uri": string,
  "downloadUri": string,
  "state": enum (State),
  "source": enum (Source),
  "error": {
    object (Status)
  },

  // metadata
  "videoMetadata": {
    object (VideoFileMetadata)
  }
  // Union type
}

    Meta të dhëna të skedarit video

    Meta të dhëna për një File video.

    Fushat
    vargu i videoDuration string ( Duration format)

    Kohëzgjatja e videos.

    Një kohëzgjatje në sekonda me deri në nëntë shifra thyesore, që mbaron me ' s '. Shembull: "3.5s" .

    Përfaqësimi JSON 
    {
  "videoDuration": string
}

    Shteti

    Gjendjet për ciklin jetësor të një Skedari.

    Numërime
    STATE_UNSPECIFIED Vlera e parazgjedhur. Kjo vlerë përdoret nëse gjendja lihet jashtë.
    PROCESSING Skedari po përpunohet dhe nuk mund të përdoret ende për përfundime.
    ACTIVE Skedari është përpunuar dhe është i disponueshëm për nxjerrje përfundimesh.
    FAILED Skedari dështoi në përpunim.

    Burimi

    Numërime
    SOURCE_UNSPECIFIED Përdoret nëse burimi nuk specifikohet.
    UPLOADED Tregon që skedari është ngarkuar nga përdoruesi.
    GENERATED Tregon se skedari është gjeneruar nga Google.
    REGISTERED Tregon se skedari është i regjistruar, dmth. një skedar i Google Cloud Storage.

    Statusi

    Lloji i Status përcakton një model gabimi logjik që është i përshtatshëm për mjedise të ndryshme programimi, duke përfshirë API-të REST dhe API-të RPC. Përdoret nga gRPC . Çdo mesazh Status përmban tre pjesë të të dhënave: kodin e gabimit, mesazhin e gabimit dhe detajet e gabimit.

    Mund të mësoni më shumë rreth këtij modeli gabimi dhe si të punoni me të në Udhëzuesin e Dizajnit të API-t .

    Fushat
    code integer

    Kodi i statusit, i cili duhet të jetë një vlerë enumrimi e google.rpc.Code .

    string message

    Një mesazh gabimi që vjen nga zhvilluesi, i cili duhet të jetë në anglisht. Çdo mesazh gabimi që vjen nga përdoruesi duhet të lokalizohet dhe të dërgohet në fushën google.rpc.Status.details ose të lokalizohet nga klienti.

    details[] object

    Një listë mesazhesh që përmbajnë detajet e gabimit. Ekziston një grup i zakonshëm llojesh mesazhesh që API-të mund të përdorin.

    Një objekt që përmban fusha të një lloji arbitrar. Një fushë shtesë "@type" përmban një URI që identifikon llojin. Shembull: { "id": 1234, "@type": "types.example.com/standard/id" } .

    Përfaqësimi JSON 
    {
  "code": integer,
  "message": string,
  "details": [
    {
      "@type": string,
      field1: ...,
      ...
    }
  ]
}