Gemini 4 Argon กับ 1 ล้านโทเค็นเอาต์พุต: การตอบกลับระดับล้านโทเค็นส่งผลต่อสแตก API ของคุณอย่างไร

ตัวเลขพาดหัวของ Gemini 4 Argon คือ 1M โทเค็น ซึ่งเป็นขีดจำกัดเอาต์พุต ไม่ใช่หน้าต่างบริบท (context window) Google กล่าวว่าการตอบสนองของ Argon เพียงครั้งเดียวสามารถรันได้ถึง 1 ล้านโทเค็น ซึ่งเป็นประมาณ 16 เท่าของขีดจำกัดเดิมที่ 64K และยังไม่ได้เผยแพร่หน้าต่างอินพุตของ Argon เลย นอกจากนี้ยังไม่มีสิ่งใดที่เรียกใช้ได้ในตอนนี้: Argon มีให้เฉพาะผู้ที่อยู่ในโครงการ Fairwind Program เท่านั้น โดยลูกค้า API แบบชำระเงินจะได้รับสิทธิ์ถัดไปเมื่อ Google เปิดการเข้าถึง (ดู วันเปิดตัวและคู่มือการเข้าถึง)

การตอบสนองที่ยาวนานเช่นนั้นทำให้สมมติฐานสามข้อที่สแต็ค API ส่วนใหญ่พึ่งพาอยู่นั้นผิดไป: การเรียกใช้เสร็จสิ้นในไม่กี่วินาที, เนื้อหาพอดีกับหน่วยความจำ, และคำขอหนึ่งมีค่าใช้จ่ายน้อยและคาดเดาได้ คู่มือนี้ครอบคลุมถึงค่าใช้จ่ายของการตอบสนองสูงสุด, การสตรีม, การหมดเวลา, ขีดจำกัดเอาต์พุต, การจัดเก็บ, และวิธีการทดสอบทั้งหมดนี้ใน Apidog ก่อนที่จะมีการเข้าถึง สำหรับภาพรวมของโมเดล โปรดดู Gemini 4 Argon คืออะไร; สำหรับรูปแบบคำขอ โปรดดู คู่มือ API ของ Gemini 4 Argon

1M โทเค็นเอาต์พุต ไม่ใช่หน้าต่างบริบท 1M

หลายหน้าที่จัดอันดับสำหรับ Argon อธิบายว่าตัวเลข 1M คือหน้าต่างบริบท และหัวข้อข่าวหนึ่งเรียกว่า "หน้าต่างบริบทที่ใหญ่ขึ้น 16 เท่า" ซึ่งเป็นการเข้าใจผิด โพสต์เปิดตัว ของ Google ระบุว่าได้ขยาย "ขีดจำกัดโทเค็นเอาต์พุตของโมเดลเป็น 1M โทเค็น ซึ่งเป็นผู้นำในอุตสาหกรรม" ตัวเลข 64K นั้นตรงกับขีดจำกัดเอาต์พุต 65,536 โทเค็นบน Gemini 3.1 Pro Preview ซึ่งเป็นโมเดล Pro ชั้นนำก่อนหน้านี้ของ Google

อินพุตเป็นตัวเลขแยกต่างหากที่ Google ยังไม่ได้ให้ การประเมินบริบทแบบยาว ซึ่งอธิบายไว้ใน ระเบียบวิธีการประเมิน ใช้พรอมต์ระหว่าง 256K ถึง 1M โทเค็น นั่นเป็นส่วนย่อยของเกณฑ์มาตรฐาน ไม่ใช่ข้อกำหนด มีข้อควรระวังด้านเอาต์พุตเช่นกัน: Vals AI ระบุว่ามีเอาต์พุตสูงสุด 262K สำหรับการกำหนดค่า Argon ที่ได้ทดสอบ Google กล่าวว่าขีดจำกัดของโมเดลคือ 1M; อย่างน้อยผู้ประเมินบุคคลที่สามรายหนึ่งเห็นขีดจำกัดที่ต่ำกว่าในจุดสิ้นสุดที่ใช้

คู่แข่งทุกรายจำกัดเอาต์พุตแบบซิงโครนัสไว้ที่ 128K ดังนั้นขีดจำกัดที่ระบุของ Argon จึงอยู่ที่ประมาณ 8 เท่าของคู่แข่ง เหตุผลของ Google คือความลึกของการให้เหตุผล: ด้วยพื้นที่ว่าง โมเดลสามารถ "สร้างโทเค็นได้หลายแสนโทเค็นในเส้นทางเดียว" และแก้ปัญหาที่ยากได้ในครั้งเดียว สำหรับวิธีการที่ผู้ให้บริการรายอื่นจัดการกับการทำงานที่ยาวนาน โปรดดู งาน 18 ชั่วโมงของ Claude Opus 5.5 และ คู่มือ API ของ GPT-6 Astra

ค่าใช้จ่ายของการตอบสนองสูงสุดหนึ่งครั้ง

กำหนดราคาขีดจำกัดก่อน เอาต์พุตจะคิดเงินที่ $10 ต่อ 1M โทเค็นในช่วงแนะนำของ Argon และ $20 หลังจากนั้น ดังนั้นการตอบสนองเต็มรูปแบบหนึ่งครั้งจึงมีค่าใช้จ่าย:

• ช่วงแนะนำ: 1,000,000 x $10/1M = $10.00 สำหรับเอาต์พุต
• มาตรฐาน: 1,000,000 x $20/1M = $20.00 สำหรับเอาต์พุต

อินพุตจะมีค่าใช้จ่ายเพิ่มเติม พรอมต์ 200,000 โทเค็นจะเพิ่ม 200,000 x $2/1M = $0.40 ในอัตราแนะนำ หรือ $0.80 ในอัตรามาตรฐาน ดังนั้นการเรียกใช้สูงสุดครั้งเดียวจะมีค่าใช้จ่าย $10.40 หรือ $20.80 งานกลางคืนที่เรียกใช้ 100 ครั้งจะมีค่าใช้จ่าย $1,040 ในอัตราแนะนำ

การคิดทำให้เห็นภาพยากขึ้น ในโมเดล Gemini ปัจจุบัน โทเค็นการคิดจะถูกเรียกเก็บเงินเป็นเอาต์พุต; Google ยังไม่ได้ระบุว่า Argon จะปฏิบัติตามกฎนั้นหรือไม่ หรือว่าการคิดจะนับรวมในขีดจำกัด 1M หรือไม่ ไม่ว่าจะด้วยวิธีใด คำตอบที่สั้นและมองเห็นได้ยังคงมีค่าใช้จ่ายเอาต์พุตจำนวนมาก คู่มือราคา Gemini 4 Argon มีสถานการณ์เพิ่มเติม รวมถึงอินพุตที่แคชไว้พร้อมส่วนลด 95%

ทำไมการสตรีมจึงจำเป็น

การเรียกใช้แบบไม่สตรีมจะไม่คืนค่าใดๆ จนกว่าการตอบสนองทั้งหมดจะเสร็จสิ้น ที่หลายแสนโทเค็น นั่นคือการเชื่อมต่อที่เงียบยาวนาน และการหมดเวลาเนื่องจากการไม่ใช้งานในสแต็คของคุณสามารถปิดการเชื่อมต่อได้ก่อนที่ไบต์แรกจะมาถึง

ให้สตรีมแทน ใน generateContent ให้เปลี่ยนวิธีการเป็น :streamGenerateContent?alt=sse และ Google จะส่งเหตุการณ์ที่เซิร์ฟเวอร์ส่ง (server-sent events) โดยมีส่วนย่อยของผู้สมัคร (partial candidates chunk) หนึ่งส่วนต่อเหตุการณ์ อ่านแต่ละเหตุการณ์เมื่อมาถึงและเขียนออกไป; อย่ารวบรวมเนื้อหาก่อน สิ่งนี้ทำงานบน Gemini 3.8 Flash ในปัจจุบัน โดยมีโมเดลอยู่ในตัวแปร เนื่องจาก Google ยังไม่ได้เผยแพร่ ID โมเดลของ Argon (การตั้งค่าอยู่ใน คู่มือ API ของ Gemini 3.8 Flash ของเรา):

import json, os, requests

MODEL = os.environ.get("GEMINI_MODEL", "gemini-3.8-flash")
URL = ("https://generativelanguage.googleapis.com/v1beta/models/"
       f"{MODEL}:streamGenerateContent?alt=sse")
body = {
    "contents": [{"parts": [{"text": "Write a test plan for every endpoint in a payments API."}]}],
    "generationConfig": {"maxOutputTokens": 60000},
}
usage = None
with requests.post(URL, json=body, stream=True, timeout=(10, 120),
                   headers={"x-goog-api-key": os.environ["GEMINI_API_KEY"]}) as r, \
        open("response.txt", "a", encoding="utf-8") as out:
    r.raise_for_status()
    for line in r.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        event = json.loads(line[5:])
        for cand in event.get("candidates", []):
            for part in cand.get("content", {}).get("parts", []):
                out.write(part.get("text", ""))
        out.flush()
        usage = event.get("usageMetadata", usage)
print(usage)

timeout=(10, 120) กำหนดการหมดเวลาการเชื่อมต่อ 10 วินาที และการหมดเวลาการอ่าน 120 วินาที ใน requests การหมดเวลาการอ่านคือช่องว่างที่ยาวที่สุดระหว่างไบต์ ไม่ใช่ระยะเวลารวม ดังนั้นสตรีมที่ส่งข้อมูลต่อเนื่องสามารถทำงานได้นานเท่าที่ต้องการ แต่ละส่วนจะถูกบันทึกลงดิสก์เมื่อมาถึง ใน 3.8 Flash ทุกเหตุการณ์จะมีการนับ usageMetadata ที่กำลังทำงานอยู่ ดังนั้นเหตุการณ์สุดท้ายจะให้จำนวนโทเค็นสุดท้ายที่คุณจะบันทึกและเรียกเก็บเงิน

การหมดเวลาที่ทุกๆ จุด

ไคลเอนต์ของคุณคือหนึ่งจุด สตรีมที่ยาวนานยังต้องผ่านพร็อกซีรีเวิร์ส, เกตเวย์ API, โหลดบาลานเซอร์, และอาจเป็นรันไทม์แบบไร้เซิร์ฟเวอร์ และส่วนใดส่วนหนึ่งเหล่านี้สามารถยุติการตอบสนองได้ก่อนเวลาอันควร:

ระวังการตัดจบที่ตายตัว หากการตอบสนองที่ยาวนานล้มเหลว ณ เวลาที่ผ่านไปเท่ากันเสมอ แสดงว่าบางจุดมีขีดจำกัดระยะเวลาที่เข้มงวดซึ่งการสตรีมไม่สามารถแก้ไขได้ และงานนั้นจำเป็นต้องย้ายออกจากเส้นทางคำขอ

รันงานที่ใช้เวลานานในเบื้องหลัง

สำหรับงานที่ใช้เวลานานที่สุด ให้นำงานออกจาก live connection Interactions API รองรับการดำเนินการในเบื้องหลังสำหรับงานที่ใช้เวลานานโดยใช้ background=true การรันในเบื้องหลังขึ้นอยู่กับการโต้ตอบที่จัดเก็บไว้: เอกสารระบุว่า store=false ไม่สามารถทำงานร่วมกับการดำเนินการในเบื้องหลังได้ ดังนั้นควรเปิดการจัดเก็บข้อมูลสำหรับคำขอเหล่านี้ สำหรับการเรียกใช้การโต้ตอบในเบื้องหลังที่เสร็จสิ้น ให้ปฏิบัติตามเอกสารของ Google; อย่าเดาที่ polling endpoints เนื่องจาก Google กล่าวว่าโมเดลใหม่จะเปิดตัวบน Interactions API ดังนั้นจึงวางแผนให้งานที่ใช้เวลานานของ Argon รันที่นั่น

จำกัดเอาต์พุตโดยตั้งใจ

ขีดจำกัด 1M เป็นขีดสูงสุด ไม่ใช่เป้าหมาย ใน generateContent, generationConfig.maxOutputTokens จำกัดการตอบสนองแต่ละครั้ง; ตัวอย่างการสตรีมกำหนดไว้ที่ 60,000 บน 3.8 Flash, การคิดคำนวณจะนับรวมกับขีดจำกัดนั้น: การทดสอบของเราที่จำกัดไว้ที่ 2,000 ได้คืนโทเค็นการคิด 1,340 และโทเค็นที่มองเห็นได้ 656 สำหรับ Interactions API ให้ยืนยันฟิลด์ output-cap ในเอกสารของ Google ก่อนที่คุณจะพึ่งพามัน จากนั้นเลือกขีดจำกัดจากค่าใช้จ่ายที่คุณจะยอมรับต่อการเรียกใช้:

การตอบสนองที่ถึงขีดจำกัดจะหยุดก่อนกำหนด ดังนั้นให้ถือว่าไม่สมบูรณ์ ตรวจสอบ finishReason ของเหตุการณ์สุดท้าย: MAX_TOKENS หมายถึงขีดจำกัดได้ตัดมันออก จากนั้นให้ดำเนินการต่อในรอบถัดไปหรือเพิ่มขีดจำกัดสำหรับงานนั้น

จัดเก็บและแยกวิเคราะห์เอาต์พุตขนาดใหญ่โดยไม่มีการบัฟเฟอร์

หนึ่งล้านโทเค็นคือข้อความขนาดหลายเมกะไบต์ต่อการตอบสนอง กฎบางประการจะช่วยป้องกันไม่ให้ระบบล่ม:

• เขียนส่วนข้อมูลเมื่อมาถึง ลงไฟล์หรืออัปโหลดวัตถุหลายส่วน แทนที่จะสร้างสตริงเดียวในหน่วยความจำ
• เก็บไฟล์บางส่วนไว้หากการเชื่อมต่อหลุด การลองใหม่แบบสุ่มสี่สุ่มห้าตั้งแต่ต้นจะสร้างและเรียกเก็บเงินเอาต์พุตอีกครั้ง
• ขอ JSON Lines เมื่อคุณต้องการโครงสร้าง เพื่อให้แต่ละบรรทัดสามารถแยกวิเคราะห์ได้เองโดยไม่ต้องรอให้เอกสารขนาดใหญ่ปิดลง
• บันทึก usageMetadata และจำนวนไบต์ ไม่ใช่เนื้อหาทั้งหมด
• ตรวจสอบขีดจำกัดของคอลัมน์และขนาดข้อความในฐานข้อมูลและคิวของคุณ ก่อนที่คำตอบขนาด 800K โทเค็นจะมาถึง

ทดสอบใน Apidog ก่อนเปิดการเข้าถึง

คุณสามารถซ้อมทั้งหมดนี้กับตัวสำรองได้ ดาวน์โหลด Apidog และดำเนินการตรวจสอบสามข้อ

ดูสตรีม ส่งคำขอสตรีมมิ่งไปยัง 3.8 Flash ด้วย GEMINI_API_KEY และ GEMINI_MODEL เป็นตัวแปรสภาพแวดล้อม Apidog จะแยกวิเคราะห์การตอบสนอง text/event-stream และแสดงแต่ละเหตุการณ์ในมุมมองไทม์ไลน์เมื่อมาถึง คุณจึงสามารถดูขนาดของส่วนข้อมูล ช่องว่าง และ usageMetadata สุดท้ายได้

สตรีมการตอบสนองปลอมที่ยาวนานกว่ามาก เอาต์พุตจริงของ 3.8 Flash สูงสุดที่ 65,536 โทเค็น ดังนั้นให้รัน mock ภายในเครื่องที่สตรีมข้อมูลมากกว่านั้นมากในรูปแบบเหตุการณ์เดียวกัน:

# long_stream_mock.py: SSE รูปแบบ Gemini สำหรับการทดสอบ parser และ timeout (ข้อมูลปลอม)
import json, time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

EVENTS, DELAY, CHUNK = 20000, 0.005, "lorem ipsum " * 40

class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        self.rfile.read(int(self.headers.get("Content-Length", 0)))
        self.send_response(200)
        self.send_header("Content-Type", "text/event-stream")
        self.end_headers()
        for i in range(EVENTS):
            event = {"candidates": [{"content": {"parts": [{"text": CHUNK}]}}]}
            if i == EVENTS - 1:  # fake counts sized like a near-max reply
                event["usageMetadata"] = {"promptTokenCount": 1200,
                    "candidatesTokenCount": 950000, "thoughtsTokenCount": 40000,
                    "totalTokenCount": 991200}
            self.wfile.write(f"data: {json.dumps(event)}\n\n".encode())
            self.wfile.flush()
            time.sleep(DELAY)

ThreadingHTTPServer(("127.0.0.1", 8787), Handler).serve_forever()

ชี้ URL พื้นฐานของสภาพแวดล้อม "mock" ไปที่ http://127.0.0.1:8787 และส่งคำขอสตรีมมิ่งเดียวกันผ่านมัน สตรีมจะรันประมาณสองนาที (128 วินาทีในการทดสอบของเรา) และมีข้อความ 9.6 ล้านตัวอักษร ซึ่งเพียงพอที่จะเปิดเผยบัฟเฟอร์ parser, พร็อกซีที่เก็บเหตุการณ์, หรือการตั้งค่า timeout ที่สั้นเกินไป

ยืนยันจำนวนโทเค็น ในคำขอ generateContent แบบไม่สตรีม ให้ยืนยันว่า candidatesTokenCount บวก thoughtsTokenCount ใน usageMetadata ยังคงอยู่ที่หรือต่ำกว่าขีดจำกัดของคุณ และค่าใช้จ่ายที่คำนวณได้ยังคงต่ำกว่าเพดานของคุณในราคา Argon คู่มือ API ของ Argon มีสคริปต์การคำนวณค่าใช้จ่ายพร้อมใช้งาน

คำถามที่พบบ่อย

1M เป็นหน้าต่างบริบทของ Gemini 4 Argon หรือไม่? ไม่ใช่ 1M เป็นขีดจำกัดเอาต์พุตต่อการตอบสนอง เพิ่มขึ้นจาก 64K Google ยังไม่ได้เผยแพร่หน้าต่างอินพุตของ Argon

การตอบสนอง 1M โทเค็นของ Argon มีค่าใช้จ่ายเท่าไร? $10 สำหรับเอาต์พุตในอัตราแนะนำ และ $20 ในอัตรามาตรฐาน บวกกับอินพุต ดู ราคา Gemini 4 Argon สำหรับสถานการณ์เพิ่มเติม

ฉันสามารถสร้างการตอบสนอง 1M โทเค็นได้ในวันนี้หรือไม่? ไม่ได้ เว้นแต่องค์กรของคุณจะอยู่ในกลุ่ม Fairwind ที่มีการเข้าถึง Argon Gemini 3.8 Flash และ 3.1 Pro Preview จำกัดเอาต์พุตที่ 65,536 โทเค็น และ Vals AI ระบุว่าเอาต์พุตสูงสุด 262K สำหรับการกำหนดค่า Argon ที่ได้ทดสอบ

ฉันต้องสตรีมการตอบสนอง Argon ที่ยาวนานหรือไม่? Google ยังไม่ได้เผยแพร่คำแนะนำการสตรีมสำหรับ Argon แต่การเรียกใช้แบบไม่สตรีมที่รันเป็นนาทีจะเผชิญกับการหมดเวลาเนื่องจากการไม่ใช้งานทุกจุดในสแต็คของคุณ ควรใช้การสตรีม หรือใช้การดำเนินการในเบื้องหลังบน Interactions API

ขีดจำกัดเอาต์พุตของ Argon เปรียบเทียบกับ GPT-6 Astra และ Claude Opus 5.5 อย่างไร? ทั้งสองจำกัดเอาต์พุตแบบซิงโครนัสที่ 128K; Anthropic อนุญาต 300K บน Batch พร้อมกับเฮดเดอร์เบต้า ขีดจำกัดที่ระบุของ Argon ที่ 1M นั้นประมาณ 8 เท่าของพวกเขา

ขั้นตอนต่อไปของคุณ

เพิ่มการสตรีมและขีดจำกัดเอาต์พุตให้กับไคลเอนต์ Gemini ของคุณตอนนี้ บน 3.8 Flash และรันมันกับสตรีมจำลองที่ยาวนานจนกว่าจะไม่มีอะไรในสแต็คของคุณตัดมันออก เมื่อ ID ของ Argon พร้อมใช้งาน ให้เปลี่ยน GEMINI_MODEL และรันการทดสอบเดียวกันซ้ำใน Apidog