दस्तावेज़ को समझना

Gemini API, PDF इनपुट के साथ काम करता है. इसमें लंबे दस्तावेज़ (3,600 पेज तक) भी शामिल हैं. Gemini मॉडल, नेटिव विज़न की मदद से PDF फ़ाइलों को प्रोसेस करते हैं. इसलिए, ये दस्तावेज़ों में मौजूद टेक्स्ट और इमेज, दोनों तरह के कॉन्टेंट को समझ सकते हैं. नेटिव PDF विज़न की मदद से, Gemini मॉडल ये काम कर सकते हैं:

  • दस्तावेज़ों में मौजूद डायग्राम, चार्ट, और टेबल का विश्लेषण करना
  • जानकारी को स्ट्रक्चर्ड आउटपुट फ़ॉर्मैट में निकालना
  • दस्तावेज़ों में मौजूद विज़ुअल और टेक्स्ट कॉन्टेंट के बारे में सवालों के जवाब देना
  • दस्तावेज़ों की ख़ास जानकारी देना
  • दस्तावेज़ के कॉन्टेंट को एचटीएमएल में ट्रांसक्राइब करना. इसमें लेआउट और फ़ॉर्मैटिंग को बनाए रखा जाता है, ताकि इसे डाउनस्ट्रीम ऐप्लिकेशन में इस्तेमाल किया जा सके

इस ट्यूटोरियल में, PDF दस्तावेज़ों को प्रोसेस करने के लिए, Gemini API का इस्तेमाल करने के कुछ संभावित तरीके दिखाए गए हैं.

PDF इनपुट

20 एमबी से कम साइज़ के PDF पेलोड के लिए, आपके पास base64 में कोड किए गए दस्तावेज़ अपलोड करने या सीधे तौर पर लोकल स्टोरेज में मौजूद फ़ाइलें अपलोड करने का विकल्प होता है.

inline_data के तौर पर

PDF दस्तावेज़ों को सीधे यूआरएल से प्रोसेस किया जा सकता है. ऐसा करने का तरीका बताने वाला कोड स्निपेट यहां दिया गया है:

DOC_URL="https://discovery.ucl.ac.uk/id/eprint/10089234/1/343019_3_art_0_py4t4l_convrt.pdf"
PROMPT="Summarize this document"
DISPLAY_NAME="base64_pdf"

# Download the PDF
wget -O "${DISPLAY_NAME}.pdf" "${DOC_URL}"

# Check for FreeBSD base64 and set flags accordingly
if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

# Base64 encode the PDF
ENCODED_PDF=$(base64 $B64FLAGS "${DISPLAY_NAME}.pdf")

# Generate content using the base64 encoded PDF
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"inline_data": {"mime_type": "application/pdf", "data": "'"$ENCODED_PDF"'"}},
          {"text": "'$PROMPT'"}
        ]
      }]
    }' 2> /dev/null > response.json

cat response.json
echo

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

# Clean up the downloaded PDF
rm "${DISPLAY_NAME}.pdf"

तकनीकी जानकारी

Gemini 1.5 Pro और 1.5 Flash, ज़्यादा से ज़्यादा 3,600 पेजों वाले दस्तावेज़ों के साथ काम करते हैं. दस्तावेज़ के पेज, टेक्स्ट डेटा के इनमें से किसी एक MIME टाइप में होने चाहिए:

  • PDF - application/pdf
  • JavaScript - application/x-javascript, text/javascript
  • Python - application/x-python, text/x-python
  • TXT - text/plain
  • एचटीएमएल - text/html
  • सीएसएस - text/css
  • मार्कडाउन - text/md
  • CSV - text/csv
  • एक्सएमएल - text/xml
  • RTF - text/rtf

दस्तावेज़ का हर पेज 258 टोकन के बराबर होता है.

मॉडल की कॉन्टेक्स्ट विंडो के अलावा, किसी दस्तावेज़ में पिक्सल की संख्या की कोई खास सीमा नहीं होती. हालांकि, बड़े पेजों को 3072x3072 पिक्सल के ज़्यादा से ज़्यादा रिज़ॉल्यूशन तक स्केल किया जाता है. ऐसा करते समय, उनके ओरिजनल आसपेक्ट रेशियो को बनाए रखा जाता है. वहीं, छोटे पेजों को 768x768 पिक्सल तक स्केल किया जाता है. कम साइज़ वाले पेजों के लिए, बैंडविड्थ के अलावा कोई और शुल्क नहीं लिया जाता. इसके अलावा, ज़्यादा रिज़ॉल्यूशन वाले पेजों की परफ़ॉर्मेंस में भी कोई सुधार नहीं होता.

सर्वोत्तम परिणामों के लिएः

  • अपलोड करने से पहले, पेजों को सही ओरिएंटेशन में घुमाएं.
  • धुंधले पेजों का इस्तेमाल न करें.
  • अगर एक पेज का इस्तेमाल किया जा रहा है, तो टेक्स्ट प्रॉम्प्ट को पेज के बाद रखें.

बड़े साइज़ के PDF

किसी भी साइज़ का दस्तावेज़ अपलोड करने के लिए, File API का इस्तेमाल किया जा सकता है. जब अनुरोध का कुल साइज़ (इसमें फ़ाइलें, टेक्स्ट प्रॉम्प्ट, सिस्टम के निर्देश वगैरह शामिल हैं) 20 एमबी से ज़्यादा हो, तो हमेशा File API का इस्तेमाल करें.

File API का इस्तेमाल करके फ़ाइल अपलोड करने के लिए, media.upload को कॉल करें. नीचे दिया गया कोड, दस्तावेज़ फ़ाइल को अपलोड करता है. इसके बाद, models.generateContent को कॉल करने के लिए फ़ाइल का इस्तेमाल करता है.

यूआरएल से बड़ी PDF फ़ाइलें

यूआरएल से उपलब्ध बड़ी PDF फ़ाइलों के लिए, File API का इस्तेमाल करें. इससे, इन दस्तावेज़ों को सीधे उनके यूआरएल से अपलोड करने और प्रोसेस करने की प्रोसेस को आसान बनाया जा सकता है:

PDF_PATH="https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf"
DISPLAY_NAME="A17_FlightPlan"
PROMPT="Summarize this document"

# Download the PDF from the provided URL
wget -O "${DISPLAY_NAME}.pdf" "${PDF_PATH}"

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

echo "MIME_TYPE: ${MIME_TYPE}"
echo "NUM_BYTES: ${NUM_BYTES}"

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=${GOOGLE_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 "@${DISPLAY_NAME}.pdf" 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-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "'$PROMPT'"},
          {"file_data":{"mime_type": "application/pdf", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

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

# Clean up the downloaded PDF
rm "${DISPLAY_NAME}.pdf"

डिवाइस में सेव किए गए बड़े PDF

NUM_BYTES=$(wc -c < "${PDF_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: application/pdf" \
  -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 "@${PDF_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=$GOOGLE_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": "application/pdf", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

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

files.get को कॉल करके, यह पुष्टि की जा सकती है कि अपलोड की गई फ़ाइल को एपीआई ने सही से सेव किया है या नहीं. साथ ही, उसका मेटाडेटा भी पाया जा सकता है. सिर्फ़ name (और एक्सटेंशन के तौर पर, uri) यूनीक होते हैं.

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

एक से ज़्यादा PDF

Gemini API, एक ही अनुरोध में कई PDF दस्तावेज़ों को प्रोसेस कर सकता है. हालांकि, ऐसा तब ही होगा, जब दस्तावेज़ों और टेक्स्ट प्रॉम्प्ट का कुल साइज़, मॉडल की कॉन्टेक्स्ट विंडो में रहे.

DOC_URL_1="https://arxiv.org/pdf/2312.11805"
DOC_URL_2="https://arxiv.org/pdf/2403.05530"
DISPLAY_NAME_1="Gemini_paper"
DISPLAY_NAME_2="Gemini_1.5_paper"
PROMPT="What is the difference between each of the main benchmarks between these two papers? Output these in a table."

# Function to download and upload a PDF
upload_pdf() {
  local doc_url="$1"
  local display_name="$2"

  # Download the PDF
  wget -O "${display_name}.pdf" "${doc_url}"

  local MIME_TYPE=$(file -b --mime-type "${display_name}.pdf")
  local NUM_BYTES=$(wc -c < "${display_name}.pdf")

  echo "MIME_TYPE: ${MIME_TYPE}"
  echo "NUM_BYTES: ${NUM_BYTES}"

  local tmp_header_file=upload-header.tmp

  # Initial resumable request
  curl "${BASE_URL}/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
    -D "${tmp_header_file}" \
    -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

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

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

  local file_uri=$(jq ".file.uri" "file_info_${display_name}.json")
  echo "file_uri for ${display_name}: ${file_uri}"

  # Clean up the downloaded PDF
  rm "${display_name}.pdf"

  echo "${file_uri}"
}

# Upload the first PDF
file_uri_1=$(upload_pdf "${DOC_URL_1}" "${DISPLAY_NAME_1}")

# Upload the second PDF
file_uri_2=$(upload_pdf "${DOC_URL_2}" "${DISPLAY_NAME_2}")

# Now generate content using both files
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"file_data": {"mime_type": "application/pdf", "file_uri": '$file_uri_1'}},
          {"file_data": {"mime_type": "application/pdf", "file_uri": '$file_uri_2'}},
          {"text": "'$PROMPT'"}
        ]
      }]
    }' 2> /dev/null > response.json

cat response.json
echo

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

आगे क्या करना है

ज़्यादा जानकारी के लिए, इन संसाधनों को देखें:

  • फ़ाइल के लिए प्रॉम्प्ट करने की रणनीतियां: Gemini API, टेक्स्ट, इमेज, ऑडियो, और वीडियो डेटा के साथ प्रॉम्प्ट करने की सुविधा देता है. इसे मल्टीमॉडल प्रॉम्प्ट भी कहा जाता है.
  • सिस्टम के निर्देश: सिस्टम के निर्देशों की मदद से, अपनी ज़रूरतों और इस्तेमाल के उदाहरणों के आधार पर, मॉडल के व्यवहार को कंट्रोल किया जा सकता है.