TH ▾
รับคีย์ API

หน้าแรกคู่มือ

อัปเดต

หน้าต่างบริบท AI Agent: การใช้ 100k โทเคน

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

ภาชนะแก้วกำลังถูกเติมด้วยบล็อกเรืองแสงขณะลูกศรวนรอบ แสดงถึงหน้าต่างบริบทของ agent

ประเด็นสำคัญ

  1. หน้าต่าง 100,000 โทเคนครอบคลุมทั้งพรอมต์และการสร้างผลลัพธ์ ดังนั้นผลลัพธ์จากฟังก์ชันที่คุณเก็บไว้ทุกอันจะลดพื้นที่สำหรับคำตอบถัดลง
  2. ในลูปของเอเจนต์ ประวัติทั้งหมดจะถูกส่งใหม่ในทุกขั้นตอน ดังนั้นข้อมูลนำเข้ารวมจะเพิ่มขึ้นตามกำลังสองของจำนวนขั้นตอน ไม่ใช่แบบเชิงเส้น
  3. ให้ตัดเอาต์พุตของฟังก์ชันเก่าออกก่อน เก็บพรอมต์ระบบและบทสนทนาล่าสุดไว้ แล้ววัดปริมาณด้วยฟิลด์ usage
  4. ลูป 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 นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API