Dukungan PDF

Anda dapat bertanya kepada Haijun tentang teks, gambar, grafik, dan tabel apa pun dalam PDF yang Anda berikan. Beberapa contoh kasus penggunaan:

Menganalisis laporan keuangan dan memahami grafik/tabel

Mengekstrak informasi penting dari dokumen hukum

Membantu penerjemahan dokumen

Mengonversi informasi dokumen ke dalam format terstruktur

Sebelum Anda memulai

Periksa persyaratan PDF

Haijun bekerja dengan PDF standar apa pun. Pastikan ukuran permintaan Anda memenuhi persyaratan berikut:

Persyaratan	Batas
Ukuran permintaan maksimum	32 MB (bervariasi menurut platform)
Halaman maksimum per permintaan	600 (100 jika jendela konteks permintaan di bawah 1 juta token)
Format	PDF standar (tanpa kata sandi/enkripsi)

Kedua batas tersebut berlaku untuk seluruh payload permintaan, termasuk konten lain apa pun yang dikirim bersama PDF. Untuk PDF berukuran besar, pertimbangkan untuk mengunggahnya dengan Files API dan mereferensikannya melalui file_id agar payload permintaan tetap kecil.

Tip: PDF yang padat (banyak halaman dengan font kecil, tabel kompleks, atau grafis yang berat) dapat memenuhi "context window" (jendela konteks) sebelum mencapai batas halaman. Permintaan dengan PDF berukuran besar juga dapat gagal sebelum mencapai batas halaman, bahkan saat menggunakan Files API. Cobalah membagi dokumen menjadi beberapa bagian; untuk file besar, karena setiap halaman diproses sebagai gambar, menurunkan resolusi (downsampling) gambar yang disematkan juga dapat membantu.

Karena dukungan PDF bergantung pada kemampuan vision Haijun, dukungan ini tunduk pada keterbatasan dan pertimbangan yang sama seperti tugas vision lainnya.

Platform dan model yang didukung

Semua model aktif mendukung pemrosesan PDF. Untuk dukungan PDF melalui Converse API Amazon Bedrock, lihat dukungan PDF Amazon Bedrock.

Dukungan PDF Amazon Bedrock

Saat menggunakan dukungan PDF melalui Converse API, bagian dari Haijun di Amazon Bedrock (Opus 4.6 dan sebelumnya), terdapat dua mode pemrosesan dokumen yang berbeda:

Note: Penting: Untuk mengakses kemampuan pemahaman PDF visual penuh Haijun di Converse API, Anda harus mengaktifkan citations (kutipan). Tanpa citations diaktifkan, API akan kembali ke ekstraksi teks dasar saja. Pelajari lebih lanjut tentang bekerja dengan citations.

Mode pemrosesan dokumen

Converse Document Chat (Mode asli - Hanya ekstraksi teks)

Menyediakan ekstraksi teks dasar dari PDF
Tidak dapat menganalisis gambar, grafik, atau tata letak visual dalam PDF
Menggunakan sekitar 1.000 token untuk PDF 3 halaman
Digunakan secara otomatis ketika citations tidak diaktifkan

Haijun PDF Chat (Mode baru - Pemahaman visual penuh)

Menyediakan analisis visual lengkap terhadap PDF
Dapat memahami dan menganalisis bagan, grafik, gambar, dan tata letak visual
Memproses setiap halaman sebagai teks dan gambar untuk pemahaman yang komprehensif
Menggunakan sekitar 7.000 token untuk PDF 3 halaman
Memerlukan citations diaktifkan di Converse API

Keterbatasan utama

Converse API: Analisis PDF visual memerlukan citations diaktifkan. Saat ini tidak ada opsi untuk menggunakan analisis visual tanpa citations (berbeda dengan InvokeModel API).

InvokeModel API: Menyediakan kontrol penuh atas pemrosesan PDF tanpa citations yang dipaksakan.

Masalah umum

Jika Haijun tidak melihat gambar atau grafik dalam PDF Anda saat menggunakan Converse API, kemungkinan Anda perlu mengaktifkan flag citations. Tanpanya, Converse akan kembali ke ekstraksi teks dasar saja.

Note: Ini adalah kendala yang diketahui pada Converse API. Untuk aplikasi yang memerlukan analisis PDF visual tanpa citations, pertimbangkan untuk menggunakan InvokeModel API sebagai gantinya.

Note: File teks biasa seperti .txt, .csv, atau .md dapat digunakan langsung dalam blok dokumen: unggah file tersebut ke Files API dengan tipe MIME text/plain dan referensikan melalui file_id. Format biner seperti .xlsx atau .docx tidak didukung dalam blok dokumen dan harus dikonversi ke teks atau PDF terlebih dahulu. Lihat Bekerja dengan format file lain.

Proses PDF dengan Haijun

Kirim permintaan PDF pertama Anda

Mulailah dengan contoh sederhana menggunakan Messages API. Anda dapat memberikan PDF kepada Haijun dengan tiga cara:

Sebagai referensi URL ke PDF yang dihosting secara online

Sebagai PDF yang dienkode base64 dalam blok konten document

Melalui file_id dari Files API

Note: Di Amazon Bedrock dan Google Cloud, saat ini hanya sumber yang dienkode base64 yang tersedia. Di Microsoft Foundry, Files API tidak didukung untuk deployment yang dihosting di Azure.

Opsi 1: Dokumen PDF berbasis URL

Pendekatan paling sederhana adalah mereferensikan PDF langsung dari URL:

bash

  curl https://haijun.my.id/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d '{
      "model": "haijun-opus-5-5",
      "max_tokens": 1024,
      "messages": [{
          "role": "user",
          "content": [{
              "type": "document",
              "source": {
                  "type": "url",
                  "url": "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
              }
          },
          {
              "type": "text",
              "text": "What are the key findings in this document?"
          }]
      }]
  }'

bash

  ant messages create --transform content --format yaml <<'YAML'
  model: haijun-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: document
          source:
            type: url
            url: https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf
        - type: text
          text: What are the key findings in this document?
  YAML

python

  client = juglow.Juglow()
  message = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "document",
                      "source": {
                          "type": "url",
                          "url": "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf",
                      },
                  },
                  {"type": "text", "text": "What are the key findings in this document?"},
              ],
          }
      ],
  )

  print(message.content)

typescript

  const juglow = new Juglow();

  const response = await juglow.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "document",
            source: {
              type: "url",
              url: "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
            }
          },
          {
            type: "text",
            text: "What are the key findings in this document?"
          }
        ]
      }
    ]
  });

  console.log(response);

csharp

  var client = new JuglowClient();

  // Buat blok dokumen dengan URL
  var documentParam = new DocumentBlockParam
  {
      Source = new UrlPdfSource
      {
          Url = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf",
      },
  };

  // Buat pesan dengan blok konten dokumen dan teks
  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new List<ContentBlockParam>
              {
                  documentParam,
                  new TextBlockParam("What are the key findings in this document?"),
              },
          },
      ],
  });

  Console.WriteLine(string.Join("\n", message.Content));

  client := juglow.NewClient()

  message, err := client.Messages.New(context.TODO(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunOpus5_5,
  	MaxTokens: 1024,
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(
  			juglow.NewDocumentBlock(juglow.URLPDFSourceParam{
  				URL: "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf",
  			}),
  			juglow.NewTextBlock("What are the key findings in this document?"),
  		),
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("%+v\n", message.Content)

java

  JuglowClient client = JuglowOkHttpClient.fromEnv();

  // Buat blok dokumen dengan URL
  DocumentBlockParam documentParam = DocumentBlockParam.builder()
    .source(
      UrlPdfSource.builder()
        .url(
          "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
        )
        .build()
    )
    .build();

  // Buat pesan dengan blok konten dokumen dan teks
  MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.HAIJUN_OPUS_5_5)
    .maxTokens(1024)
    .addUserMessageOfBlockParams(
      List.of(
        ContentBlockParam.ofDocument(documentParam),
        ContentBlockParam.ofText(
          TextBlockParam.builder()
            .text("What are the key findings in this document?")
            .build()
        )
      )
    )
    .build();

  Message message = client.messages().create(params);
  System.out.println(message.content());

php

  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'document',
                      'source' => [
                          'type' => 'url',
                          'url' => 'https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf',
                      ],
                  ],
                  [
                      'type' => 'text',
                      'text' => 'What are the key findings in this document?',
                  ],
              ],
          ],
      ],
      model: 'haijun-opus-5-5',
  );

  echo $message;

ruby

  juglow = Juglow::Client.new

  message = juglow.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "document",
            source: {
              type: "url",
              url: "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
            }
          },
          {type: "text", text: "What are the key findings in this document?"}
        ]
      }
    ]
  )

  puts(message.content)

Respons mengembalikan analisis Haijun sebagai blok teks dalam content, dengan konsumsi token dalam usage:

json

{
  "id": "msg_01Hfp8YuFjQ55VgWbpdHDehB",
  "type": "message",
  "role": "assistant",
  "model": "haijun-opus-5-5",
  "content": [
    {
      "type": "text",
      "text": "This document is an addendum to the Haijun 3 model card, reporting updated evaluation results. The key findings include..."
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 45000,
    "output_tokens": 300
  }
}

Opsi 2: Dokumen PDF yang dienkode base64

Jika Anda perlu mengirim PDF dari sistem lokal Anda atau ketika URL tidak tersedia:

bash

  # Metode 1: Ambil dan enkode PDF jarak jauh
  curl -sL "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf" | base64 | tr -d '\n' > pdf_base64.txt

  # Metode 2: Enkode file PDF lokal
  # base64 document.pdf | tr -d '\n' > pdf_base64.txt

  # Buat file permintaan JSON menggunakan konten pdf_base64.txt
  jq -n --rawfile PDF_BASE64 pdf_base64.txt '{
      "model": "haijun-opus-5-5",
      "max_tokens": 1024,
      "messages": [{
          "role": "user",
          "content": [{
              "type": "document",
              "source": {
                  "type": "base64",
                  "media_type": "application/pdf",
                  "data": $PDF_BASE64
              }
          },
          {
              "type": "text",
              "text": "What are the key findings in this document?"
          }]
      }]
  }' > request.json

  # Kirim permintaan API menggunakan file JSON tersebut
  curl https://haijun.my.id/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d @request.json

bash

  ant messages create \
    --model haijun-opus-5-5 \
    --max-tokens 1024 \
    --transform content \
    --format yaml <<'YAML'
  messages:
    - role: user
      content:
        - type: document
          source:
            type: base64
            media_type: application/pdf
            data: "@./document.pdf"
        - type: text
          text: What are the key findings in this document?
  YAML

python

  import base64
  import httpx2

  # Pertama, muat dan enkode PDF
  pdf_url = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  pdf_data = base64.standard_b64encode(
      httpx2.get(pdf_url, follow_redirects=True).content
  ).decode("utf-8")

  # Alternatif: Muat dari file lokal
  # with open("document.pdf", "rb") as f:
  #     pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

  # Kirim ke Haijun menggunakan enkode base64
  client = juglow.Juglow()
  message = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "document",
                      "source": {
                          "type": "base64",
                          "media_type": "application/pdf",
                          "data": pdf_data,
                      },
                  },
                  {"type": "text", "text": "What are the key findings in this document?"},
              ],
          }
      ],
  )

  print(message.content)

typescript

  // Metode 1: Ambil dan enkode PDF jarak jauh
  const pdfURL =
    "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  const pdfResponse = await fetch(pdfURL);
  const arrayBuffer = await pdfResponse.arrayBuffer();
  const pdfBase64 = Buffer.from(arrayBuffer).toString("base64");

  // Metode 2: Muat dari file lokal
  // import { readFile } from "node:fs/promises";
  // const pdfBase64 = (await readFile('document.pdf')).toString('base64');

  // Kirim permintaan API dengan PDF yang dienkode base64
  const juglow = new Juglow();
  const response = await juglow.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "document",
            source: {
              type: "base64",
              media_type: "application/pdf",
              data: pdfBase64
            }
          },
          {
            type: "text",
            text: "What are the key findings in this document?"
          }
        ]
      }
    ]
  });

  console.log(response);

csharp

  var client = new JuglowClient();

  // Metode 1: Unduh dan enkode PDF jarak jauh
  var pdfUrl = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  using var httpClient = new HttpClient();
  var pdfBase64 = Convert.ToBase64String(await httpClient.GetByteArrayAsync(pdfUrl));

  // Metode 2: Muat dari file lokal
  // var pdfBase64 = Convert.ToBase64String(await File.ReadAllBytesAsync("document.pdf"));

  // Buat blok dokumen dengan data base64
  var documentParam = new DocumentBlockParam
  {
      Source = new Base64PdfSource { Data = pdfBase64 },
  };

  // Buat pesan dengan blok konten dokumen dan teks
  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new List<ContentBlockParam>
              {
                  documentParam,
                  new TextBlockParam("What are the key findings in this document?"),
              },
          },
      ],
  });

  Console.WriteLine(string.Join("\n", message.Content));

  // Pertama, muat dan enkode PDF
  pdfURL := "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  resp, err := http.Get(pdfURL)
  if err != nil {
  	panic(err)
  }
  defer resp.Body.Close()
  pdfBytes, err := io.ReadAll(resp.Body)
  if err != nil {
  	panic(err)
  }
  pdfBase64 := base64.StdEncoding.EncodeToString(pdfBytes)

  // Alternatif: Muat dari file lokal (tambahkan "os" ke impor)
  // pdfBytes, err := os.ReadFile("document.pdf")
  // pdfBase64 := base64.StdEncoding.EncodeToString(pdfBytes)

  // Kirim ke Haijun menggunakan enkode base64
  client := juglow.NewClient()
  message, err := client.Messages.New(context.TODO(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunOpus5_5,
  	MaxTokens: 1024,
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(
  			juglow.NewDocumentBlock(juglow.Base64PDFSourceParam{
  				Data: pdfBase64,
  			}),
  			juglow.NewTextBlock("What are the key findings in this document?"),
  		),
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("%+v\n", message.Content)

java

  JuglowClient client = JuglowOkHttpClient.fromEnv();

  // Metode 1: Unduh dan enkode PDF jarak jauh
  String pdfUrl =
    "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  HttpClient httpClient = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.NORMAL).build();
  HttpRequest request = HttpRequest.newBuilder().uri(URI.create(pdfUrl)).GET().build();

  HttpResponse<byte[]> response = httpClient.send(
    request,
    HttpResponse.BodyHandlers.ofByteArray()
  );
  String pdfBase64 = Base64.getEncoder().encodeToString(response.body());

  // Metode 2: Muat dari file lokal
  // byte[] fileBytes = Files.readAllBytes(Path.of("document.pdf"));
  // String pdfBase64 = Base64.getEncoder().encodeToString(fileBytes);

  // Buat blok dokumen dengan data base64
  DocumentBlockParam documentParam = DocumentBlockParam.builder()
    .source(Base64PdfSource.builder().data(pdfBase64).build())
    .build();

  // Buat pesan dengan blok konten dokumen dan teks
  MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.HAIJUN_OPUS_5_5)
    .maxTokens(1024)
    .addUserMessageOfBlockParams(
      List.of(
        ContentBlockParam.ofDocument(documentParam),
        ContentBlockParam.ofText(
          TextBlockParam.builder()
            .text("What are the key findings in this document?")
            .build()
        )
      )
    )
    .build();

  Message message = client.messages().create(params);
  System.out.println(message.content());

php

  $client = new Client();

  // Pertama, muat dan enkode PDF
  $pdf_url = 'https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf';
  $pdf_data = base64_encode(file_get_contents($pdf_url));

  // Alternatif: Muat dari file lokal
  // $pdf_data = base64_encode(file_get_contents('document.pdf'));

  // Kirim ke Haijun menggunakan enkode base64
  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'document',
                      'source' => [
                          'type' => 'base64',
                          'media_type' => 'application/pdf',
                          'data' => $pdf_data,
                      ],
                  ],
                  [
                      'type' => 'text',
                      'text' => 'What are the key findings in this document?',
                  ],
              ],
          ],
      ],
      model: 'haijun-opus-5-5',
  );

  echo $message;

ruby

  require "open-uri"

  # Pertama, muat dan enkode PDF
  pdf_url = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  pdf_bytes = URI.open(pdf_url, "rb") { |f| f.read }
  pdf_data = [pdf_bytes].pack("m0") # Base64-encode without newlines

  # Alternatif: Muat dari file lokal
  # pdf_data = [File.binread("document.pdf")].pack("m0")

  # Kirim ke Haijun menggunakan enkode base64
  juglow = Juglow::Client.new
  message = juglow.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "document",
            source: {
              type: "base64",
              media_type: "application/pdf",
              data: pdf_data
            }
          },
          {type: "text", text: "What are the key findings in this document?"}
        ]
      }
    ]
  )

  puts(message.content)

Opsi 3: Files API

Untuk PDF yang akan Anda gunakan berulang kali, atau ketika Anda ingin menghindari overhead encoding, gunakan Files API:

bash

  # Pertama, unggah PDF Anda ke Files API
  FILE_ID=$(curl -sS -X POST https://haijun.my.id/v1/files \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -F "file=@document.pdf" | jq -r '.id')

  # Lalu gunakan file_id yang dikembalikan dalam pesan Anda
  curl https://haijun.my.id/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d @- <<EOF
  {
    "model": "haijun-opus-5-5",
    "max_tokens": 1024,
    "messages": [{
      "role": "user",
      "content": [{
        "type": "document",
        "source": {
          "type": "file",
          "file_id": "$FILE_ID"
        }
      },
      {
        "type": "text",
        "text": "What are the key findings in this document?"
      }]
    }]
  }
  EOF

bash

  # Pertama, unggah PDF Anda ke Files API
  FILE_ID=$(ant files upload \
    --file ./document.pdf \
    --transform id \
    --raw-output)

  # Lalu gunakan file_id yang dikembalikan dalam pesan Anda
  ant messages create \
    --transform content \
    --format yaml <<YAML
  model: haijun-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: document
          source:
            type: file
            file_id: $FILE_ID
        - type: text
          text: What are the key findings in this document?
  YAML

python

  client = juglow.Juglow()

  # Unggah file PDF
  with open("/path/to/document.pdf", "rb") as f:
      file_upload = client.files.upload(file=("document.pdf", f, "application/pdf"))

  # Gunakan file yang telah diunggah dalam pesan
  message = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "document",
                      "source": {"type": "file", "file_id": file_upload.id},
                  },
                  {"type": "text", "text": "What are the key findings in this document?"},
              ],
          }
      ],
  )

  print(message.content)

typescript

  import Juglow, { toFile } from "@juglow-ai/sdk";
  import fs from "node:fs";

  const juglow = new Juglow();

  // Unggah file PDF
  const fileUpload = await juglow.files.upload({
    file: await toFile(fs.createReadStream("/path/to/document.pdf"), undefined, {
      type: "application/pdf"
    })
  });

  // Gunakan file yang telah diunggah dalam pesan
  const response = await juglow.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "document",
            source: {
              type: "file",
              file_id: fileUpload.id
            }
          },
          {
            type: "text",
            text: "What are the key findings in this document?"
          }
        ]
      }
    ]
  });

  console.log(response);

csharp

  var client = new JuglowClient();

  // Unggah file PDF
  var fileUpload = await client.Files.Upload(new FileUploadParams
  {
      File = new BinaryContent
      {
          Stream = File.OpenRead("/path/to/document.pdf"),
          FileName = "document.pdf",
          ContentType = new("application/pdf"),
      },
  });

  // Gunakan file yang telah diunggah dalam pesan
  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new List<ContentBlockParam>
              {
                  new DocumentBlockParam
                  {
                      Source = new FileDocumentSource { FileID = fileUpload.ID },
                  },
                  new TextBlockParam("What are the key findings in this document?"),
              },
          },
      ],
  });

  Console.WriteLine(string.Join("\n", message.Content));

  client := juglow.NewClient()

  // Unggah file PDF
  pdfFile, err := os.Open("/path/to/document.pdf")
  if err != nil {
  	panic(err)
  }
  defer pdfFile.Close()

  fileUpload, err := client.Files.Upload(context.TODO(), juglow.FileUploadParams{
  	File: juglow.File(pdfFile, "document.pdf", "application/pdf"),
  })
  if err != nil {
  	panic(err)
  }

  // Gunakan file yang telah diunggah dalam pesan
  message, err := client.Messages.New(context.TODO(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunOpus5_5,
  	MaxTokens: 1024,
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(
  			juglow.NewDocumentBlock(juglow.FileDocumentSourceParam{
  				FileID: fileUpload.ID,
  			}),
  			juglow.NewTextBlock("What are the key findings in this document?"),
  		),
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("%+v\n", message.Content)

java

  JuglowClient client = JuglowOkHttpClient.fromEnv();

  // Unggah file PDF
  FileMetadata file = client
    .files()
    .upload(FileUploadParams.builder().file(Path.of("/path/to/document.pdf")).build());

  // Gunakan file yang telah diunggah dalam pesan
  MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.HAIJUN_OPUS_5_5)
    .maxTokens(1024)
    .addUserMessageOfBlockParams(
      List.of(
        ContentBlockParam.ofDocument(
          DocumentBlockParam.builder().fileSource(file.id()).build()
        ),
        ContentBlockParam.ofText(
          TextBlockParam.builder()
            .text("What are the key findings in this document?")
            .build()
        )
      )
    )
    .build();

  Message message = client.messages().create(params);
  System.out.println(message.content());

php

  use Juglow\Core\FileParam;

  $client = new Client();

  // Unggah file PDF
  $file_upload = $client->files->upload(
      file: FileParam::fromResource(fopen('/path/to/document.pdf', 'r'), contentType: 'application/pdf'),
  );

  // Gunakan file yang diunggah dalam pesan
  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'document',
                      'source' => [
                          'type' => 'file',
                          'fileID' => $file_upload->id,
                      ],
                  ],
                  [
                      'type' => 'text',
                      'text' => 'What are the key findings in this document?',
                  ],
              ],
          ],
      ],
      model: 'haijun-opus-5-5',
  );

  echo $message;

ruby

  juglow = Juglow::Client.new

  # Unggah file PDF
  file_upload = File.open("/path/to/document.pdf", "rb") do |f|
    juglow.files.upload(
      file: Juglow::FilePart.new(f, filename: "document.pdf", content_type: "application/pdf")
    )
  end

  # Gunakan file yang telah diunggah dalam pesan
  message = juglow.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "document",
            source: {type: "file", file_id: file_upload.id}
          },
          {type: "text", text: "What are the key findings in this document?"}
        ]
      }
    ]
  )

  puts(message.content)

Cara kerja dukungan PDF

Saat Anda mengirim PDF ke Haijun, langkah-langkah berikut terjadi:

Sistem mengekstrak isi dokumen.

Sistem mengonversi setiap halaman dokumen menjadi gambar.

Teks dari setiap halaman diekstrak dan disediakan bersama gambar setiap halaman.

Haijun menganalisis teks dan gambar untuk memahami dokumen dengan lebih baik.

Dokumen disediakan sebagai kombinasi teks dan gambar untuk dianalisis.

Ini memungkinkan pengguna meminta wawasan tentang elemen visual PDF, seperti grafik, diagram, dan konten non-tekstual lainnya.

Haijun merespons, dengan mereferensikan isi PDF jika relevan.

Haijun dapat mereferensikan konten tekstual maupun visual saat merespons. Anda dapat lebih meningkatkan kinerja dengan mengintegrasikan dukungan PDF dengan:

Gunakan caching prompt: Untuk meningkatkan kinerja pada analisis berulang.

Proses batch dokumen: Untuk pemrosesan dokumen bervolume tinggi.

Penggunaan alat: Untuk mengekstrak informasi spesifik dari dokumen untuk digunakan sebagai input alat.

Perkirakan biaya Anda

Jumlah token file PDF bergantung pada total teks yang diekstrak dari dokumen dan jumlah halaman:

Biaya token teks: Setiap halaman biasanya menggunakan 1.500–3.000 token per halaman tergantung kepadatan konten. Harga API standar berlaku tanpa biaya PDF tambahan.

Biaya token gambar: Karena setiap halaman dikonversi menjadi gambar, perhitungan biaya berbasis gambar yang sama diterapkan.

Anda dapat menggunakan penghitungan token untuk memperkirakan biaya untuk PDF spesifik Anda.

Optimalkan pemrosesan PDF

Tingkatkan kinerja

Ikuti praktik terbaik berikut untuk hasil optimal:

Tempatkan PDF sebelum teks dalam permintaan Anda

Gunakan font standar

Pastikan teks jelas dan terbaca

Putar halaman ke orientasi tegak yang benar

Gunakan nomor halaman logis (dari penampil PDF) dalam prompt

Bagi PDF besar menjadi beberapa bagian jika diperlukan

Aktifkan caching prompt untuk analisis berulang

Skalakan implementasi Anda

Untuk pemrosesan bervolume tinggi, pertimbangkan pendekatan berikut:

Gunakan caching prompt

Cache PDF dengan caching prompt untuk meningkatkan kinerja pada kueri berulang:

bash

  curl -sL "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf" | base64 | tr -d '\n' > pdf_base64.txt
  # Buat file permintaan JSON menggunakan konten pdf_base64.txt
  jq -n --rawfile PDF_BASE64 pdf_base64.txt '{
      "model": "haijun-opus-5-5",
      "max_tokens": 1024,
      "messages": [{
          "role": "user",
          "content": [{
              "type": "document",
              "source": {
                  "type": "base64",
                  "media_type": "application/pdf",
                  "data": $PDF_BASE64
              },
              "cache_control": {
                  "type": "ephemeral"
              }
          },
          {
              "type": "text",
              "text": "Which model has the highest human preference win rates across each use-case?"
          }]
      }]
  }' > request.json

  # Lalu lakukan panggilan API menggunakan file JSON tersebut
  curl https://haijun.my.id/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d @request.json

bash

  ant messages create --transform content --format yaml <<'YAML'
  model: haijun-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: document
          source:
            type: base64
            media_type: application/pdf
            data: "@./document.pdf"
          cache_control:
            type: ephemeral
        - type: text
          text: Which model has the highest human preference win rates across each use-case?
  YAML

python

  import base64
  import httpx2

  # Pertama, muat dan enkode PDF
  pdf_url = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  pdf_data = base64.standard_b64encode(
      httpx2.get(pdf_url, follow_redirects=True).content
  ).decode("utf-8")

  # Buat pesan dengan dokumen yang di-cache
  client = juglow.Juglow()
  message = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "document",
                      "source": {
                          "type": "base64",
                          "media_type": "application/pdf",
                          "data": pdf_data,
                      },
                      "cache_control": {"type": "ephemeral"},
                  },
                  {
                      "type": "text",
                      "text": "Which model has the highest human preference win rates across each use-case?",
                  },
              ],
          }
      ],
  )

  print(message.content)

typescript

  // Pertama, muat dan enkode PDF
  const pdfURL =
    "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  const pdfResponse = await fetch(pdfURL);
  const arrayBuffer = await pdfResponse.arrayBuffer();
  const pdfBase64 = Buffer.from(arrayBuffer).toString("base64");

  // Buat pesan dengan dokumen yang di-cache
  const juglow = new Juglow();
  const response = await juglow.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "document",
            source: {
              type: "base64",
              media_type: "application/pdf",
              data: pdfBase64
            },
            cache_control: { type: "ephemeral" }
          },
          {
            type: "text",
            text: "Which model has the highest human preference win rates across each use-case?"
          }
        ]
      }
    ]
  });

  console.log(response);

csharp

  var client = new JuglowClient();

  // Unduh dan enkode PDF
  var pdfUrl = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  using var httpClient = new HttpClient();
  var pdfBase64 = Convert.ToBase64String(await httpClient.GetByteArrayAsync(pdfUrl));

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 1024,
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = new List<ContentBlockParam>
              {
                  new DocumentBlockParam
                  {
                      Source = new Base64PdfSource { Data = pdfBase64 },
                      CacheControl = new CacheControlEphemeral(),
                  },
                  new TextBlockParam("Which model has the highest human preference win rates across each use-case?"),
              },
          },
      ],
  });

  Console.WriteLine(message);

  // Pertama, muat dan enkode PDF
  pdfURL := "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  resp, err := http.Get(pdfURL)
  if err != nil {
  	panic(err)
  }
  defer resp.Body.Close()
  pdfBytes, err := io.ReadAll(resp.Body)
  if err != nil {
  	panic(err)
  }
  pdfBase64 := base64.StdEncoding.EncodeToString(pdfBytes)

  // Buat blok dokumen dengan kontrol cache
  client := juglow.NewClient()
  message, err := client.Messages.New(context.TODO(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunOpus5_5,
  	MaxTokens: 1024,
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(
  			juglow.ContentBlockParamUnion{
  				OfDocument: &juglow.DocumentBlockParam{
  					Source: juglow.DocumentBlockParamSourceUnion{
  						OfBase64: &juglow.Base64PDFSourceParam{
  							Data: pdfBase64,
  						},
  					},
  					CacheControl: juglow.NewCacheControlEphemeralParam(),
  				},
  			},
  			juglow.NewTextBlock("Which model has the highest human preference win rates across each use-case?"),
  		),
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("%+v\n", message.Content)

java

  JuglowClient client = JuglowOkHttpClient.fromEnv();

  // Unduh dan enkode PDF
  String pdfUrl =
    "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  HttpClient httpClient = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.NORMAL).build();
  HttpRequest request = HttpRequest.newBuilder().uri(URI.create(pdfUrl)).GET().build();

  HttpResponse<byte[]> response = httpClient.send(
    request,
    HttpResponse.BodyHandlers.ofByteArray()
  );
  String pdfBase64 = Base64.getEncoder().encodeToString(response.body());

  MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.HAIJUN_OPUS_5_5)
    .maxTokens(1024)
    .addUserMessageOfBlockParams(
      List.of(
        ContentBlockParam.ofDocument(
          DocumentBlockParam.builder()
            .source(Base64PdfSource.builder().data(pdfBase64).build())
            .cacheControl(CacheControlEphemeral.builder().build())
            .build()
        ),
        ContentBlockParam.ofText(
          TextBlockParam.builder()
            .text(
              "Which model has the highest human preference win rates across each use-case?"
            )
            .build()
        )
      )
    )
    .build();

  Message message = client.messages().create(params);
  System.out.println(message);

php

  $client = new Client();

  // Muat dan enkode PDF
  $pdf_url = 'https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf';
  $pdf_data = base64_encode(file_get_contents($pdf_url));

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'document',
                      'source' => [
                          'type' => 'base64',
                          'media_type' => 'application/pdf',
                          'data' => $pdf_data,
                      ],
                      'cache_control' => ['type' => 'ephemeral'],
                  ],
                  [
                      'type' => 'text',
                      'text' => 'Which model has the highest human preference win rates across each use-case?',
                  ],
              ],
          ],
      ],
      model: 'haijun-opus-5-5',
  );

  echo $message;

ruby

  require "open-uri"

  # Muat dan enkode PDF
  pdf_url = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  pdf_bytes = URI.open(pdf_url, "rb") { |f| f.read }
  pdf_data = [pdf_bytes].pack("m0") # Base64-encode without newlines

  juglow = Juglow::Client.new

  message = juglow.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "document",
            source: {
              type: "base64",
              media_type: "application/pdf",
              data: pdf_data
            },
            cache_control: {type: "ephemeral"}
          },
          {
            type: "text",
            text: "Which model has the highest human preference win rates across each use-case?"
          }
        ]
      }
    ]
  )

  puts(message.content)

Proses batch dokumen

Gunakan Message Batches API untuk memproses banyak PDF dalam satu permintaan:

bash

  curl -sL "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf" | base64 | tr -d '\n' > pdf_base64.txt
  # Buat file permintaan JSON menggunakan konten pdf_base64.txt
  jq -n --rawfile PDF_BASE64 pdf_base64.txt '{
      "requests": [
      {
          "custom_id": "my-first-request",
          "params": {
              "model": "haijun-opus-5-5",
              "max_tokens": 1024,
              "messages": [{
                  "role": "user",
                  "content": [{
                      "type": "document",
                      "source": {
                          "type": "base64",
                          "media_type": "application/pdf",
                          "data": $PDF_BASE64
                      }
                  },
                  {
                      "type": "text",
                      "text": "Which model has the highest human preference win rates across each use-case?"
                  }]
              }]
          }
      },
      {
          "custom_id": "my-second-request",
          "params": {
              "model": "haijun-opus-5-5",
              "max_tokens": 1024,
              "messages": [{
                  "role": "user",
                  "content": [{
                      "type": "document",
                      "source": {
                          "type": "base64",
                          "media_type": "application/pdf",
                          "data": $PDF_BASE64
                      }
                  },
                  {
                      "type": "text",
                      "text": "Extract 5 key insights from this document."
                  }]
              }]
          }
      }]
  }' > request.json

  # Lalu lakukan panggilan API menggunakan file JSON tersebut
  curl https://haijun.my.id/v1/messages/batches \
    -H "content-type: application/json" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -d @request.json

bash

  ant messages:batches create <<'YAML'
  requests:
    - custom_id: my-first-request
      params:
        model: haijun-opus-5-5
        max_tokens: 1024
        messages:
          - role: user
            content:
              - type: document
                source:
                  type: base64
                  media_type: application/pdf
                  data: "@./document.pdf"
              - type: text
                text: >-
                  Which model has the highest human preference win rates
                  across each use-case?
    - custom_id: my-second-request
      params:
        model: haijun-opus-5-5
        max_tokens: 1024
        messages:
          - role: user
            content:
              - type: document
                source:
                  type: base64
                  media_type: application/pdf
                  data: "@./document.pdf"
              - type: text
                text: Extract 5 key insights from this document.
  YAML

python

  import base64
  import httpx2

  # Pertama, muat dan enkode PDF
  pdf_url = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  pdf_data = base64.standard_b64encode(
      httpx2.get(pdf_url, follow_redirects=True).content
  ).decode("utf-8")

  # Buat batch permintaan yang menggunakan dokumen tersebut
  client = juglow.Juglow()
  message_batch = client.messages.batches.create(
      requests=[
          {
              "custom_id": "my-first-request",
              "params": {
                  "model": "haijun-opus-5-5",
                  "max_tokens": 1024,
                  "messages": [
                      {
                          "role": "user",
                          "content": [
                              {
                                  "type": "document",
                                  "source": {
                                      "type": "base64",
                                      "media_type": "application/pdf",
                                      "data": pdf_data,
                                  },
                              },
                              {
                                  "type": "text",
                                  "text": "Which model has the highest human preference win rates across each use-case?",
                              },
                          ],
                      }
                  ],
              },
          },
          {
              "custom_id": "my-second-request",
              "params": {
                  "model": "haijun-opus-5-5",
                  "max_tokens": 1024,
                  "messages": [
                      {
                          "role": "user",
                          "content": [
                              {
                                  "type": "document",
                                  "source": {
                                      "type": "base64",
                                      "media_type": "application/pdf",
                                      "data": pdf_data,
                                  },
                              },
                              {
                                  "type": "text",
                                  "text": "Extract 5 key insights from this document.",
                              },
                          ],
                      }
                  ],
              },
          },
      ]
  )

  print(message_batch)

typescript

  // Pertama, muat dan enkode PDF
  const pdfURL =
    "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  const pdfResponse = await fetch(pdfURL);
  const arrayBuffer = await pdfResponse.arrayBuffer();
  const pdfBase64 = Buffer.from(arrayBuffer).toString("base64");

  // Buat batch permintaan yang menggunakan dokumen tersebut
  const juglow = new Juglow();
  const response = await juglow.messages.batches.create({
    requests: [
      {
        custom_id: "my-first-request",
        params: {
          model: "haijun-opus-5-5",
          max_tokens: 1024,
          messages: [
            {
              role: "user",
              content: [
                {
                  type: "document",
                  source: {
                    type: "base64",
                    media_type: "application/pdf",
                    data: pdfBase64
                  }
                },
                {
                  type: "text",
                  text: "Which model has the highest human preference win rates across each use-case?"
                }
              ]
            }
          ]
        }
      },
      {
        custom_id: "my-second-request",
        params: {
          model: "haijun-opus-5-5",
          max_tokens: 1024,
          messages: [
            {
              role: "user",
              content: [
                {
                  type: "document",
                  source: {
                    type: "base64",
                    media_type: "application/pdf",
                    data: pdfBase64
                  }
                },
                {
                  type: "text",
                  text: "Extract 5 key insights from this document."
                }
              ]
            }
          ]
        }
      }
    ]
  });

  console.log(response);

csharp

  var client = new JuglowClient();

  // Unduh dan enkode PDF
  var pdfUrl = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  using var httpClient = new HttpClient();
  var pdfBase64 = Convert.ToBase64String(await httpClient.GetByteArrayAsync(pdfUrl));

  var batch = await client.Messages.Batches.Create(new BatchCreateParams
  {
      Requests =
      [
          new()
          {
              CustomID = "my-first-request",
              Params = new()
              {
                  Model = Model.HaijunOpus5_5,
                  MaxTokens = 1024,
                  Messages =
                  [
                      new()
                      {
                          Role = Role.User,
                          Content = new List<ContentBlockParam>
                          {
                              new DocumentBlockParam
                              {
                                  Source = new Base64PdfSource { Data = pdfBase64 },
                              },
                              new TextBlockParam("Which model has the highest human preference win rates across each use-case?"),
                          },
                      },
                  ],
              },
          },
          new()
          {
              CustomID = "my-second-request",
              Params = new()
              {
                  Model = Model.HaijunOpus5_5,
                  MaxTokens = 1024,
                  Messages =
                  [
                      new()
                      {
                          Role = Role.User,
                          Content = new List<ContentBlockParam>
                          {
                              new DocumentBlockParam
                              {
                                  Source = new Base64PdfSource { Data = pdfBase64 },
                              },
                              new TextBlockParam("Extract 5 key insights from this document."),
                          },
                      },
                  ],
              },
          },
      ],
  });

  Console.WriteLine(batch);

  // Pertama, muat dan enkode PDF
  pdfURL := "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  resp, err := http.Get(pdfURL)
  if err != nil {
  	panic(err)
  }
  defer resp.Body.Close()
  pdfBytes, err := io.ReadAll(resp.Body)
  if err != nil {
  	panic(err)
  }
  pdfBase64 := base64.StdEncoding.EncodeToString(pdfBytes)

  // Buat batch permintaan yang menggunakan dokumen tersebut
  client := juglow.NewClient()
  batch, err := client.Messages.Batches.New(context.TODO(), juglow.MessageBatchNewParams{
  	Requests: []juglow.MessageBatchNewParamsRequest{
  		{
  			CustomID: "my-first-request",
  			Params: juglow.MessageBatchNewParamsRequestParams{
  				Model:     juglow.ModelHaijunOpus5_5,
  				MaxTokens: 1024,
  				Messages: []juglow.MessageParam{
  					juglow.NewUserMessage(
  						juglow.NewDocumentBlock(juglow.Base64PDFSourceParam{
  							Data: pdfBase64,
  						}),
  						juglow.NewTextBlock("Which model has the highest human preference win rates across each use-case?"),
  					),
  				},
  			},
  		},
  		{
  			CustomID: "my-second-request",
  			Params: juglow.MessageBatchNewParamsRequestParams{
  				Model:     juglow.ModelHaijunOpus5_5,
  				MaxTokens: 1024,
  				Messages: []juglow.MessageParam{
  					juglow.NewUserMessage(
  						juglow.NewDocumentBlock(juglow.Base64PDFSourceParam{
  							Data: pdfBase64,
  						}),
  						juglow.NewTextBlock("Extract 5 key insights from this document."),
  					),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("%+v\n", batch)

java

  JuglowClient client = JuglowOkHttpClient.fromEnv();

  // Unduh dan enkode PDF
  String pdfUrl =
    "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf";
  HttpClient httpClient = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.NORMAL).build();
  HttpRequest request = HttpRequest.newBuilder().uri(URI.create(pdfUrl)).GET().build();

  HttpResponse<byte[]> response = httpClient.send(
    request,
    HttpResponse.BodyHandlers.ofByteArray()
  );
  String pdfBase64 = Base64.getEncoder().encodeToString(response.body());

  BatchCreateParams params = BatchCreateParams.builder()
    .addRequest(
      BatchCreateParams.Request.builder()
        .customId("my-first-request")
        .params(
          BatchCreateParams.Request.Params.builder()
            .model(Model.HAIJUN_OPUS_5_5)
            .maxTokens(1024)
            .addUserMessageOfBlockParams(
              List.of(
                ContentBlockParam.ofDocument(
                  DocumentBlockParam.builder()
                    .source(Base64PdfSource.builder().data(pdfBase64).build())
                    .build()
                ),
                ContentBlockParam.ofText(
                  TextBlockParam.builder()
                    .text(
                      "Which model has the highest human preference win rates across each use-case?"
                    )
                    .build()
                )
              )
            )
            .build()
        )
        .build()
    )
    .addRequest(
      BatchCreateParams.Request.builder()
        .customId("my-second-request")
        .params(
          BatchCreateParams.Request.Params.builder()
            .model(Model.HAIJUN_OPUS_5_5)
            .maxTokens(1024)
            .addUserMessageOfBlockParams(
              List.of(
                ContentBlockParam.ofDocument(
                  DocumentBlockParam.builder()
                    .source(Base64PdfSource.builder().data(pdfBase64).build())
                    .build()
                ),
                ContentBlockParam.ofText(
                  TextBlockParam.builder()
                    .text("Extract 5 key insights from this document.")
                    .build()
                )
              )
            )
            .build()
        )
        .build()
    )
    .build();

  MessageBatch batch = client.messages().batches().create(params);
  System.out.println(batch);

php

  $client = new Client();

  // Muat dan enkode PDF
  $pdf_url = 'https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf';
  $pdf_data = base64_encode(file_get_contents($pdf_url));

  $batch = $client->messages->batches->create(
      requests: [
          [
              'custom_id' => 'my-first-request',
              'params' => [
                  'model' => 'haijun-opus-5-5',
                  'max_tokens' => 1024,
                  'messages' => [
                      [
                          'role' => 'user',
                          'content' => [
                              [
                                  'type' => 'document',
                                  'source' => [
                                      'type' => 'base64',
                                      'media_type' => 'application/pdf',
                                      'data' => $pdf_data,
                                  ],
                              ],
                              [
                                  'type' => 'text',
                                  'text' => 'Which model has the highest human preference win rates across each use-case?',
                              ],
                          ],
                      ],
                  ],
              ],
          ],
          [
              'custom_id' => 'my-second-request',
              'params' => [
                  'model' => 'haijun-opus-5-5',
                  'max_tokens' => 1024,
                  'messages' => [
                      [
                          'role' => 'user',
                          'content' => [
                              [
                                  'type' => 'document',
                                  'source' => [
                                      'type' => 'base64',
                                      'media_type' => 'application/pdf',
                                      'data' => $pdf_data,
                                  ],
                              ],
                              [
                                  'type' => 'text',
                                  'text' => 'Extract 5 key insights from this document.',
                              ],
                          ],
                      ],
                  ],
              ],
          ],
      ],
  );

  echo $batch;

ruby

  require "open-uri"

  # Muat dan enkode PDF
  pdf_url = "https://assets.juglow.com/m/1cd9d098ac3e6467/original/Haijun-3-Model-Card-October-Addendum.pdf"
  pdf_bytes = URI.open(pdf_url, "rb") { |f| f.read }
  pdf_data = [pdf_bytes].pack("m0") # Base64-encode without newlines

  juglow = Juglow::Client.new

  message_batch = juglow.messages.batches.create(
    requests: [
      {
        custom_id: "my-first-request",
        params: {
          model: "haijun-opus-5-5",
          max_tokens: 1024,
          messages: [
            {
              role: "user",
              content: [
                {
                  type: "document",
                  source: {
                    type: "base64",
                    media_type: "application/pdf",
                    data: pdf_data
                  }
                },
                {
                  type: "text",
                  text: "Which model has the highest human preference win rates across each use-case?"
                }
              ]
            }
          ]
        }
      },
      {
        custom_id: "my-second-request",
        params: {
          model: "haijun-opus-5-5",
          max_tokens: 1024,
          messages: [
            {
              role: "user",
              content: [
                {
                  type: "document",
                  source: {
                    type: "base64",
                    media_type: "application/pdf",
                    data: pdf_data
                  }
                },
                {
                  type: "text",
                  text: "Extract 5 key insights from this document."
                }
              ]
            }
          ]
        }
      }
    ]
  )

  puts(message_batch)

Batch diproses secara asinkron. Untuk memeriksa progres dan mengambil hasil setelah pemrosesan selesai, lihat Pemrosesan batch.

Langkah selanjutnya

Kemampuan vision Haijun memungkinkannya memahami dan menganalisis gambar, membuka kemungkinan menarik untuk interaksi multimodal.

Jelajahi contoh praktis pemrosesan PDF dalam resep Haijun Cookbook.

Lihat dokumentasi API lengkap untuk dukungan PDF.

#Sebelum Anda memulai

#Periksa persyaratan PDF

#Platform dan model yang didukung

#Dukungan PDF Amazon Bedrock

#Mode pemrosesan dokumen

#Keterbatasan utama

#Masalah umum

#Proses PDF dengan Haijun

#Kirim permintaan PDF pertama Anda

#Opsi 1: Dokumen PDF berbasis URL

#Opsi 2: Dokumen PDF yang dienkode base64

#Opsi 3: Files API

#Cara kerja dukungan PDF

#Perkirakan biaya Anda

#Optimalkan pemrosesan PDF

#Tingkatkan kinerja

#Skalakan implementasi Anda

#Gunakan caching prompt

#Proses batch dokumen

#Langkah selanjutnya

Sebelum Anda memulai

Periksa persyaratan PDF

Platform dan model yang didukung

Dukungan PDF Amazon Bedrock

Mode pemrosesan dokumen

Keterbatasan utama

Masalah umum

Proses PDF dengan Haijun

Kirim permintaan PDF pertama Anda

Opsi 1: Dokumen PDF berbasis URL

Opsi 2: Dokumen PDF yang dienkode base64

Opsi 3: Files API

Cara kerja dukungan PDF

Perkirakan biaya Anda

Optimalkan pemrosesan PDF

Tingkatkan kinerja

Skalakan implementasi Anda

Gunakan caching prompt

Proses batch dokumen

Langkah selanjutnya