หน้าแรกคู่มือ
อัปเดต
หน้าต่างบริบท AI Agent: การใช้ 100k โทเคน
หน้าต่างบริบท AI agent คือพื้นที่โทเคนที่แชร์ร่วมกันระหว่างพรอมต์ ผลลัพธ์จากฟังก์ชัน และการตอบกลับของโมเดล บน API นี้พื้นที่คือ 100,000 โทเคน และ agent ที่ทำงานยาวนานมักเติมพื้นที่นี้เร็วกว่าที่คาด

ประเด็นสำคัญ
- หน้าต่าง 100,000 โทเคนครอบคลุมทั้งพรอมต์และการสร้างผลลัพธ์ ดังนั้นผลลัพธ์จากฟังก์ชันที่คุณเก็บไว้ทุกอันจะลดพื้นที่สำหรับคำตอบถัดลง
- ในลูปของเอเจนต์ ประวัติทั้งหมดจะถูกส่งใหม่ในทุกขั้นตอน ดังนั้นข้อมูลนำเข้ารวมจะเพิ่มขึ้นตามกำลังสองของจำนวนขั้นตอน ไม่ใช่แบบเชิงเส้น
- ให้ตัดเอาต์พุตของฟังก์ชันเก่าออกก่อน เก็บพรอมต์ระบบและบทสนทนาล่าสุดไว้ แล้ววัดปริมาณด้วยฟิลด์ usage
- ลูป 20 ขั้นตอนที่มีโทเคนใหม่ 1,500 โทเคนต่อขั้นตอน มีค่าใช้จ่ายรวมประมาณ $0.055
ไม่ต้องใช้บัตร หลังสมัคร ให้รับเครดิตทดลองใช้ฟรี $0.50 ด้วยคลิกเดียว (หนึ่งครั้งต่อคน)
รับคีย์ APIคำตอบสั้นๆ: งบประมาณโทเคนรวม 100,000 โทเคน
เมื่อผู้คนค้นหาหน้าต่างบริบท AI agent พวกเขาต้องการรู้ว่า agent จำได้แค่ไหนก่อนจะล้มเหลว ที่นี่ตัวเลขคือ 100,000 โทเคน และนับทุกอย่าง: พรอมต์ระบบ นิยามฟังก์ชัน ข้อความก่อนหน้านี้ทุกข้อความ ผลลัพธ์จากฟังก์ชันทุกผลลัพธ์ และการตอบกลับที่โมเดลจะเขียนต่อ การตอบกลับสามารถใช้พื้นที่ที่เหลือ และmax_tokens เป็นตัวเลือก
นั่นทำให้หน้าต่างเป็นงบประมาณ ไม่ใช่พื้นที่จัดเก็บ แชทบอทมักไม่เข้าใกล้ขีดจำกัด Agent ที่เรียกใช้ฟังก์ชันในลูปสามารถถึงขีดจำกัดได้ในบ่ายวันเดียว เพราะแต่ละขั้นตอนเพิ่มข้อความโมเดลและผลลัพธ์ฟังก์ชันลงในประวัติ และประวัติทั้งหมดจะถูกส่งอีกครั้งในการเรียกถัดไป โมเดลไม่มีหน่วยความจำระหว่างคำขอ สิ่งที่ดูเหมือนหน่วยความจำคือการที่คุณส่งสำเนาการสนทนาใหม่
อะไรกันแน่ที่เติมเต็มหน้าต่างในเอเยนต์
พื้นที่ส่วนใหญ่ไม่ใช่ข้อความของผู้ใช้ ติดตามแหล่งข้อมูลห้าแหล่งนี้และคุณสามารถทำนายได้ว่ารันจะหมดหน้าต่างเมื่อไหร่
- พรอมต์ระบบ กฎ บุคลิก และรูปแบบเอาต์พุต มักมีขนาด 500 ถึง 2,000 โทเคน และส่งในทุกคำขอ
- คำจำกัดความของฟังก์ชัน ชื่อฟังก์ชัน คำอธิบาย และสคีมา JSON แต่ละอันนับเป็นโทเคน ฟังก์ชันสิบตัวพร้อมคำอธิบายยาวอาจใช้โทเคนหลายพันตัวก่อนข้อความผู้ใช้แรก
- ผลลัพธ์จากฟังก์ชัน สาเหตุหลัก มักเป็นผลลัพธ์การค้นหา การดัมพ์ไฟล์ หรือแถวฐานข้อมูลที่มีขนาดหลายพันโทเคน และจะคงอยู่ในประวัติเว้นแต่คุณจะลบออก
- ข้อความจากผู้ช่วย การให้เหตุผลที่เขียนออกมาเป็นข้อความ และอาร์กิวเมนต์
tool_callsที่โมเดลสร้าง - การตอบที่กำลังสร้าง มันต้องการพื้นที่เช่นกัน หากพรอมต์มีขนาด 99,000 โทเคน คำตอบจะมีพื้นที่เหลือประมาณ 1,000 โทเคน
API รายงานจำนวนที่แน่นอนในบล็อก usage ของแต่ละการตอบ ดังนั้นคุณไม่ต้องเดา บันทึก prompt_tokens หลังจากทุกขั้นตอนและคุณจะเห็นแนวโน้ม
ตัวอย่างการคำนวณ: ลูปฟังก์ชัน 20 ขั้นตอน
สมมติเอเยนต์ที่มีจุดเริ่มต้นขนาด 3,000 โทเคน (พรอมต์ระบบรวมกับคำจำกัดความของฟังก์ชัน) แต่ละขั้นตอนเพิ่มประมาณ 1,500 โทเคนเข้าสู่ประวัติ: การเรียกใช้ฟังก์ชันของโมเดลและผลลัพธ์ของฟังก์ชัน นอกจากนี้ยังเขียนเอาต์พุตประมาณ 300 โทเคนต่อขั้นตอน เอเยนต์ทำงาน 20 ขั้นตอน
อินพุตที่ขั้นตอน k คือ 3,000 + 1,500 × (k − 1) เมื่อรวมตลอด 20 ขั้นตอน:
- 3,000 × 20 = 60,000 โทเคนสำหรับจุดเริ่มต้นคงที่ ซึ่งส่งซ้ำทุกครั้ง
- 1,500 × (0 + 1 + ... + 19) = 1,500 × 190 = 285,000 โทเคนของประวัติที่สะสม
- อินพุตรวม: 345,000 โทเคน เอาต์พุตรวม: 20 × 300 = 6,000 โทเคน
| รายการ | โทเคน | ราคาต่อ 1M | ต้นทุน |
|---|---|---|---|
| อินพุต | 345,000 | $0.15 | $0.05175 |
| เอาต์พุต | 6,000 | $0.50 | $0.003 |
| รวม | ประมาณ $0.055 |
สองสิ่งที่โดดเด่น ประการแรก บริบทที่ขั้นตอน 20 คือ 3,000 + 1,500 × 19 = 31,500 โทเคน ซึ่งยังอยู่ในหน้าต่าง แต่คุณจ่ายสำหรับอินพุต 345,000 โทเคน เพราะประวัติถูกส่งซ้ำทุกครั้ง ประการที่สอง การเรียกครั้งเดียวที่มีหน้าต่างเต็มทั้งหมด (อินพุต 100,000 โทเคน) มีค่าใช้จ่ายด้านอินพุต 100,000 × $0.15 / 1M = $0.015 บริบทยาวมีค่าใช้จ่ายต่อการเรียกที่ถูก; ต้นทุนเกิดจากการทำซ้ำบริบทตลอดหลายขั้นตอน ดู หน้าราคา สำหรับอัตราและโบนัสการเติมเงิน
จำนวนขั้นตอนที่พอดีก่อนที่หน้าต่างจะเต็ม
คุณสามารถประมาณการนี้ได้ก่อนเขียนโค้ดใดๆ เก็บพื้นที่สำรองสำหรับคำตอบ เช่น 20,000 โทเคน ซึ่งเหลืองบประมาณพรอมต์ 80,000 โทเคน ด้วยจุดเริ่มต้น 3,000 โทเคนและเพิ่ม 1,500 โทเคนต่อขั้นตอน ประวัติจะถึงงบประมาณนี้หลังจาก (80,000 − 3,000) / 1,500 หรือประมาณ 51 ขั้นตอน
ตอนนี้คำนวณราคาของการรันความยาวนั้น ตลอด 51 ขั้นตอน อินพุตคือ 3,000 × 51 + 1,500 × (0 + 1 + ... + 50) = 153,000 + 1,500 × 1,275 = 153,000 + 1,912,500 = 2,065,500 โทเคน เอาต์พุตที่ 300 โทเคนต่อขั้นตอนคือ 15,300 โทเคน ค่าใช้จ่าย: 2,065,500 × $0.15 / 1M = $0.30983 บวก 15,300 × $0.50 / 1M = $0.00765 ดังนั้นประมาณ $0.32
เปรียบเทียบกับรัน 20 ขั้นตอนที่ประมาณ $0.055 รันนี้ยาวกว่า 2.55 เท่าแต่มีค่าใช้จ่ายมากกว่าประมาณ 5.8 เท่า เพราะแต่ละขั้นตอนมีประวัติที่ยาวขึ้น นี่คือเหตุผลในทางปฏิบัติที่ต้องตัดทอน: มันจำกัดต้นทุนต่อขั้นตอนและปกป้องหน้าต่าง
การเก็บเอเยนต์ให้อยู่ในหน้าต่าง
ลบเอาต์พุตจากฟังก์ชันเก่าก่อน
ผลลัพธ์จากฟังก์ชันดิบเป็นส่วนที่ใหญ่ที่สุดและมีประโยชน์น้อยที่สุดของประวัติเก่า เมื่อโมเดลดำเนินการกับรายการไฟล์แล้ว มักไม่จำเป็นต้องใช้รายการนั้นอีก แทนที่ผลลัพธ์เก่าด้วยข้อความแทนบรรทัดเดียวเช่น "ลบผลลัพธ์แล้ว 4,200 โทเคน" หรือลบคู่ดังกล่าวออกทั้งหมด
สรุปส่วนกลาง เก็บทั้งสองด้าน
เก็บพรอมต์ระบบและการสนทนาไม่กี่รอบสุดท้ายไว้ตามต้นฉบับ สำหรับส่วนที่เหลือ ให้ถามโมเดลให้สรุปการตัดสินใจและข้อเท็จจริงที่พบ แล้วเก็บสรุปนั้นเป็นข้อความเดียว เรียกใช้การสรุปนี้ก่อนถึงขีดจำกัด ไม่ใช่หลังจากนั้น
ย้ายข้อเท็จจริงออกจากบทสนทนา
หากเอเจนต์เรียนรู้สิ่งใดที่ต้องเก็บไว้เป็นเวลานานหลายชั่วโมง ให้เขียนข้อมูลนั้นลงไฟล์หรือฐานข้อมูลขนาดเล็กผ่านเครื่องมือ แล้วอ่านข้อมูลกลับเมื่อต้องการ วิธีนี้ประหยัดกว่าการส่งข้อมูลในทุกคำขอ และข้อมูลจะยังอยู่แม้มีการรีสตาร์ท
ทำให้สคีมาของเครื่องมือสั้นที่สุด
ตัดคำอธิบายให้เหลือเฉพาะสิ่งที่โมเดลต้องการเพื่อเลือกเครื่องมือ ส่งเฉพาะเครื่องมือที่เกี่ยวข้องกับขั้นตอนปัจจุบันของงานเท่านั้น
โค้ด: ลูปเรียกใช้เครื่องมือพร้อมงบประมาณโทเคน
ลูปนี้จะตัดข้อความที่เก่าที่สุดออกเมื่อขนาดโดยประมาณเกินงบประมาณ 80,000 โทเคน เพื่อให้เหลือพื้นที่สำหรับคำตอบ การประมาณค่านี้ใช้การหารจำนวนอักขระด้วยสี่ ซึ่งเป็นค่าประมาณทั่วไปสำหรับข้อความภาษาอังกฤษ; จำนวนที่แท้จริงจะส่งกลับใน usage การตัดข้อความจะลบข้อความ tool ที่ไม่มีคู่ออก เพื่อให้ผลลัพธ์ไม่ปรากฏโดยไม่มีคำเรียกใช้
import json, os
from openai import OpenAI
client = OpenAI(base_url="https://api.aivideogenapi.com/v1", api_key=os.environ["API_KEY"])
BUDGET = 80_000
tools = [{"type": "function", "function": {
"name": "get_scene_length",
"description": "Return the length of a scene in seconds",
"parameters": {"type": "object",
"properties": {"scene": {"type": "integer"}},
"required": ["scene"]}}}]
def rough_tokens(messages):
return sum(len(json.dumps(m)) for m in messages) // 4
def trim(messages):
system, rest = messages[0], messages[1:]
while rough_tokens([system] + rest) > BUDGET and len(rest) > 4:
rest.pop(0)
while rest and rest[0]["role"] == "tool":
rest.pop(0)
return [system] + rest
def run_tool(name, args):
return json.dumps({"seconds": 4 * args["scene"]}) # stub
messages = [
{"role": "system", "content": "You plan video scenes. Use tools for lengths."},
{"role": "user", "content": "Total the length of scenes 1 to 5."},
]
for step in range(20):
resp = client.chat.completions.create(
model="uncensored", messages=trim(messages), tools=tools)
msg = resp.choices[0].message
messages.append(msg.model_dump(exclude_none=True))
print(step, resp.usage.prompt_tokens)
if not msg.tool_calls:
print(msg.content)
break
for call in msg.tool_calls:
result = run_tool(call.function.name, json.loads(call.function.arguments))
messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
การเรียกใช้เครื่องมือใช้รูปแบบของ OpenAI: tools, tool_choice และผลลัพธ์ส่งกลับเป็น role: "tool" docs ระบุพารามิเตอร์ที่ส่งผ่าน
ขีดจำกัดที่สำคัญนอกเหนือจากหน้าต่าง
หน้าต่างบริบทเป็นข้อจำกัดหนึ่ง แอเจนต์ยังชนขีดจำกัดอัตราคำขอ คีย์แบบเต็มอนุญาตคำขอพร้อมกัน 8 รายการและ 300 รายการต่อนาที; คีย์แบบทดลองใช้อนุญาต 2 รายการและ 60 รายการ วงลูปที่แคบพร้อมซับแอเจนต์แบบขนานสามารถเกินขีดจำกัดคำขอพร้อมกันได้เร็ว API ตอบกลับด้วย HTTP 429 และรหัสข้อผิดพลาด concurrency หรือ rate_limited และเมื่อโหลดเกินชั่วคราวด้วยเฮดเดอร์ Retry-After: 5 รอตามนั้นแล้วลองใหม่
หากคุณใช้สตรีมมิง โปรดจำไว้ว่าคำขอที่สตรีมจะครอบครองช่องคำขอพร้อมกันจนกว่าสตรีมจะสิ้นสุด ไคลเอนต์ที่ค้างและไม่ปิดสตรีมจะคงช่องนั้นไว้
ขนาดสูงสุดของบอดี้คือ 8 MB ซึ่งมากกว่าข้อความ 100,000 โทเคนมาก ดังนั้นหน้าต่างจึงเป็นขีดจำกัดที่คุณจะพบก่อน สำหรับตัวอย่างสายการผลิตที่เน้นข้อความล้วนที่สร้างบน API นี้ ดูที่ คู่มือสคริปต์วิดีโอ เมื่อคุณพร้อมที่จะรัน ให้ สร้างคีย์ API; ผู้ใช้ใหม่สามารถรับเครดิตทดลองใช้ $0.50 ได้ด้วยการคลิกเพียงครั้งเดียว ใช้ได้ 7 วัน และไม่จำเป็นต้องใส่ข้อมูลการชำระเงิน
คู่มือเพิ่มเติม
ถาม-ตอบ
หน้าต่างบริบทใหญ่แค่ไหน?
100,000 โทเคน นับรวมทั้งพรอมต์และการตอบกลับรวมกัน การตอบกลับสามารถใช้พื้นที่ที่เหลือจากพรอมต์ได้
โมเดลจำคำขอก่อนหน้านี้ได้หรือไม่?
ไม่ แต่ละคำขอเป็นอิสระต่อกัน ดังนั้นโค้ดของคุณต้องส่งข้อความทั้งหมดที่โมเดลต้องการเห็นอีกครั้ง
เกิดอะไรขึ้นเมื่อฉันเกินขีดจำกัด?
คำขอใส่ในหน้าต่างไม่พอ ดังนั้นให้ตัดหรือสรุปประวัติก่อนส่ง คำขอที่ล้มเหลวจะไม่ถูกเรียกเก็บเงิน
ฉันจะนับโทเคนอย่างไร
อ่านค่า prompt_tokens และ completion_tokens จากบล็อก usage ของแต่ละการตอบกลับ หรือใช้การประมาณคร่าวๆ ว่าสี่ตัวอักษรต่อโทเคนสำหรับภาษาอังกฤษ ก่อนส่ง
คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด