การอนุมานตามลำดับความสำคัญ

Gemini Priority API เป็นระดับการอนุมานแบบพรีเมียมที่ออกแบบมาสำหรับภาระงานที่สำคัญต่อธุรกิจ ซึ่งต้องใช้เวลาในการตอบสนองที่ต่ำกว่าและความน่าเชื่อถือสูงสุดในราคาพรีเมียม ระบบจะให้ความสำคัญกับการเข้าชมระดับลำดับความสำคัญมากกว่าการเข้าชม API มาตรฐานและระดับ Flex

การอนุมานแบบลำดับความสำคัญพร้อมให้บริการแก่ผู้ใช้ระดับที่ 2 และ 3 ในปลายทาง GenerateContent API และ Interactions API

วิธีใช้รายการสำคัญ

หากต้องการใช้ระดับลำดับความสำคัญ ให้ตั้งค่าฟิลด์ service_tier ในเนื้อหาคำขอเป็น priority ระดับเริ่มต้นคือระดับมาตรฐานหากละเว้นฟิลด์นี้

from google import genai

client = genai.Client()

try:
    response = client.models.generate_content(
        model="gemini-3.6-flash",
        contents="Triage this critical customer support ticket immediately.",
        config={"service_tier": "priority"},
    )

    # Validate for graceful downgrade
    if response.sdk_http_response.headers.get("x-gemini-service-tier") == "standard":
        print("Warning: Priority limit exceeded, processed at Standard tier.")

    print(response.text)

except Exception as e:
    # Standard error handling (e.g., DEADLINE_EXCEEDED)
    print(f"Error during API call: {e}")

import {GoogleGenAI} from '@google/genai';

const ai = new GoogleGenAI({});

async function main() {
  try {
      const result = await ai.models.generateContent({
          model: "gemini-3.6-flash",
          contents: "Triage this critical customer support ticket immediately.",
          config: {serviceTier: "priority"},
      });

      // Validate for graceful downgrade
      if (result.sdkHttpResponse.headers.get("x-gemini-service-tier") === "standard") {
          console.log("Warning: Priority limit exceeded, processed at Standard tier.");
      }

      console.log(result.text);

  } catch (e) {
      console.log(`Error during API call: ${e}`);
  }
}

await main();

package main

import (
    "context"
    "fmt"
    "log"
    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    resp, err := client.Models.GenerateContent(
        ctx,
        "gemini-3.6-flash",
        genai.Text("Triage this critical customer support ticket immediately."),
        &genai.GenerateContentConfig{
            ServiceTier: "priority",
        },
    )
    if err != nil {
        log.Fatalf("Error during API call: %v", err)
    }

    // Validate for graceful downgrade
    if resp.SDKHTTPResponse.Header.Get("x-gemini-service-tier") == "standard" {
        fmt.Println("Warning: Priority limit exceeded, processed at Standard tier.")
    }

    fmt.Println(resp.Text())
}

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.6-flash:generateContent?key=$GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts":[{"text": "Analyze user sentiment in real time"}]
  }],
  "service_tier": "priority"
}'

วิธีการทำงานของการอนุมานแบบลำดับความสำคัญ

การอนุมานแบบลำดับความสำคัญจะกำหนดเส้นทางคำขอไปยังคิวการประมวลผลที่มีความสำคัญสูง ซึ่งให้ประสิทธิภาพที่รวดเร็วและคาดการณ์ได้สำหรับแอปพลิเคชันที่ผู้ใช้มองเห็น กลไกหลักคือการลดระดับฝั่งเซิร์ฟเวอร์ลงเป็นการประมวลผลมาตรฐานอย่างเหมาะสมสำหรับการเข้าชมที่เกินขีดจำกัดแบบไดนามิก เพื่อให้มั่นใจถึงความเสถียรของแอปพลิเคชันแทนที่จะทำให้คำขอไม่สำเร็จ

สิทธิประโยชน์สำคัญ

• เวลาในการตอบสนองต่ำ: ออกแบบมาให้ใช้เวลาตอบสนองเป็นวินาทีสำหรับเครื่องมือ AI แบบอินเทอร์แอกทีฟที่ผู้ใช้มองเห็น
• ความน่าเชื่อถือสูง: ระบบจะถือว่าการเข้าชมมีความสำคัญสูงสุดและไม่สามารถลดระดับได้
• การลดลงอย่างค่อยเป็นค่อยไป: ระบบจะลดระดับการเข้าชมที่เพิ่มขึ้นซึ่งเกินขีดจำกัดแบบไดนามิก ลงเป็นระดับ Standard โดยอัตโนมัติเพื่อทำการประมวลผลแทนที่จะทำให้คำขอไม่สำเร็จ ซึ่งจะช่วยป้องกันการหยุดทำงานของบริการ
• ความยุ่งยากต่ำ: ใช้วิธี generateContent แบบซิงโครนัสแบบเดียวกับระดับ มาตรฐานและระดับ Flex

กรณีการใช้งาน

การประมวลผลแบบลำดับความสำคัญเหมาะอย่างยิ่งสำหรับเวิร์กโฟลว์ที่สำคัญต่อธุรกิจ ซึ่งประสิทธิภาพและความน่าเชื่อถือมีความสำคัญสูงสุด

• แอปพลิเคชัน AI แบบอินเทอร์แอกทีฟ: แชทบ็อตและผู้ช่วยด้านการบริการลูกค้าที่ ผู้ใช้จ่ายเงินในราคาพรีเมียมและคาดหวังการตอบสนองที่รวดเร็วและสม่ำเสมอ
• กลไกการตัดสินใจแบบเรียลไทม์: ระบบที่ต้องใช้ผลลัพธ์ที่น่าเชื่อถือสูงและมีเวลาในการตอบสนองต่ำ เช่น การจัดลำดับความสำคัญของตั๋วแบบสดหรือการตรวจจับการฉ้อโกง
• ฟีเจอร์สำหรับลูกค้าพรีเมียม: นักพัฒนาแอปที่ต้องรับประกันวัตถุประสงค์ระดับการให้บริการ ที่สูงขึ้นสำหรับลูกค้าที่ชำระเงิน

ขีดจำกัดอัตรา

การใช้งานแบบลำดับความสำคัญจะมีขีดจำกัดอัตราของตัวเอง แม้ว่าระบบจะนับการใช้งานรวมกับขีดจำกัดอัตราการเข้าชมแบบอินเทอร์แอกทีฟโดยรวมก็ตาม ขีดจำกัดอัตราเริ่มต้นสำหรับการอนุมานแบบลำดับความสำคัญคือ 0.3 เท่าของขีดจำกัดอัตรามาตรฐานสำหรับโมเดล / ระดับ

ตรรกะการลดระดับอย่างเหมาะสม

หากมีการใช้งานเกินขีดจำกัดแบบลำดับความสำคัญเนื่องจากความหนาแน่น ระบบจะลดระดับ คำขอที่ล้นออกมาเป็นการประมวลผลแบบมาตรฐาน โดยอัตโนมัติและอย่างเหมาะสม แทนที่จะ ทำให้คำขอไม่สำเร็จด้วยข้อผิดพลาด 503 หรือ 429 ระบบจะเรียกเก็บเงินสำหรับคำขอที่ลดระดับในอัตรามาตรฐาน ไม่ใช่อัตราพรีเมียมแบบลำดับความสำคัญ

ความรับผิดชอบของไคลเอ็นต์

• การตรวจสอบการตอบสนอง: นักพัฒนาแอปควรตรวจสอบx-gemini-service-tier ส่วนหัวในการตอบสนองของ API เพื่อตรวจหาว่าระบบลดระดับคำขอลงเป็น standardบ่อยหรือไม่
• การลองใหม่: ไคลเอ็นต์ต้องใช้ตรรกะการลองใหม่/Exponential Backoff สำหรับ ข้อผิดพลาดมาตรฐาน เช่น DEADLINE_EXCEEDED

การกำหนดราคา

การอนุมานแบบลำดับความสำคัญมีราคาแพงกว่า API มาตรฐาน 75-100% และเรียกเก็บเงินต่อโทเค็น

โมเดลที่รองรับ

โมเดลต่อไปนี้รองรับการอนุมานแบบลำดับความสำคัญ

ขั้นตอนถัดไป

อ่านเกี่ยวกับตัวเลือกการอนุมานและการเพิ่มประสิทธิภาพอื่นๆ ของ Gemini ได้ที่

• การอนุมานแบบ Flex เพื่อลดต้นทุน 50%
• Batch API สำหรับการประมวลผลแบบอะซิงโครนัสภายใน 24 ชั่วโมง
• การแคชบริบท เพื่อลดต้นทุนโทเค็นอินพุต