TH ▾
รับคีย์ API

คู่มือการเรียกใช้ฟังก์ชัน API LLM Models สำหรับเอเจนต์

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

อัปเดต

ภาพไอโซเมตริกของทรงกลมที่เคลื่อนผ่านบล็อกเครื่องมือรอบเทอร์มินัลกลาง แสดงถึงเวิร์กโฟลว์ของเอเจนต์
01

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

  • เอนด์พอยต์รองรับ tools, tool_choice, streamed tool_calls และ tool results
  • จำกัดลูปของคุณ ตรวจสอบความถูกต้องของอาร์กิวเมนต์เครื่องมือ และลองใหม่เมื่อได้รับข้อผิดพลาด 429 โดยรอระยะเวลาสั้นๆ
  • รักษาจำนวน worker แบบขนานไว้ที่ 8 หรือน้อยกว่าสำหรับคีย์เต็ม; การสตรีมจะครอบครองช่องจนกว่าจะเสร็จสิ้น
  • การรันเอเจนต์แบบหกขั้นตอนพร้อมบริบทที่เพิ่มขึ้น มีค่าใช้จ่ายประมาณ 0.5 เซนต์

สิ่งที่ agent ต้องการจาก API

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

API นี้ครอบคลุมจุดเหล่านั้นผ่านอินเทอร์เฟซมาตรฐานของ OpenAI รองรับ tools และ tool_choice, ส่งคืน tool_calls ทั้งในการตอบกลับปกติและแบบสตรีม และรับผลลัพธ์จากเครื่องมือเป็นข้อความที่มี role: "tool" โหมด JSON มีให้ผ่าน response_format หน้าต่างบริบทรองรับ 100,000 โทเคน สำหรับพรอมต์รวมกับการสร้างผลลัพธ์ และรหัสโมเดลคือ uncensored

เนื่องจากฝั่งเฟรมเวิร์คเป็นเพียงไคลเอนต์ของ OpenAI ไลบรารี agent ส่วนใหญ่ที่ให้คุณตั้งค่า base URL จะใช้งานได้ คุณชี้ไปที่ https://api.llmmodelsapi.com/v1 จัดเตรียมคีย์ของคุณ และระบุชื่อโมเดล รายละเอียดการติดตั้งอยู่ใน เอกสารประกอบ และคุณสามารถรับคีย์ได้จาก หน้าคีย์

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

พรอมต์ระบบที่ช่วยให้ลูปทำงานได้ถูกต้อง

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

คุณคือผู้ช่วยวิจัย คุณสามารถเรียกใช้เครื่องมือ search_notes และ read_note ได้ เรียกใช้เครื่องมือก็ต่อเมื่อคุณต้องการข้อมูลที่คุณยังไม่มี ใช้การเรียกใช้เครื่องมือไม่เกินห้าครั้ง เมื่อคุณมีข้อมูลเพียงพอ ให้ตอบด้วยคำตอบสั้นๆ และระบุ ID ของโน้ตที่คุณใช้ หากโน้ตไม่มีคำตอบ ให้บอกตรงๆ

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

ตั้งค่า temperature ต่ำสำหรับการเรียกใช้เครื่องมือ ค่าประมาณ 0.2 ถึง 0.4 จะทำให้ชื่อเครื่องมือและรูปแบบอาร์กิวเมนต์คงที่ หากเอเจนต์ของคุณยังเขียนข้อความสร้างสรรค์ในส่วนท้าย คุณสามารถเพิ่ม temperature สำหรับการเรียกสุดท้ายนั้นเท่านั้น พารามิเตอร์ seed จะถูกส่งผ่าน ซึ่งช่วยเมื่อคุณต้องการทำซ้ำการรันขณะดีบัก

สำหรับ agent เรื่องผู้ใหญ่และบทบาทสมมติ รูปแบบเดียวกันนี้ใช้ได้: ใส่บุคลิก กฎของฉาก และเครื่องมือในข้อความระบบ โมเดลได้รับการปรับแต่งให้ตอบโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย เนื้อหาทางเพศที่เกี่ยวข้องกับผู้เยาว์ยังคงถูกห้าม

ลูป agent ขั้นพื้นฐานใน Python

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

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")

NOTES = {
    "n1": "Invoice 114 was paid on March 3.",
    "n2": "Invoice 115 is overdue by 12 days.",
}

def search_notes(query):
    return [{"id": k, "text": v} for k, v in NOTES.items() if query.lower() in v.lower()]

TOOLS = [{
    "type": "function",
    "function": {
        "name": "search_notes",
        "description": "Search internal notes by keyword",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"],
        },
    },
}]

SYSTEM = "You are a research assistant. Use search_notes when needed, at most five calls. Then answer briefly."

def run(question, max_steps=6):
    messages = [
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": question},
    ]
    for step in range(max_steps):
        resp = client.chat.completions.create(
            model="uncensored",
            messages=messages,
            tools=TOOLS,
            temperature=0.3,
            max_tokens=500,
        )
        msg = resp.choices[0].message
        messages.append(msg)
        if not msg.tool_calls:
            return msg.content
        for call in msg.tool_calls:
            try:
                args = json.loads(call.function.arguments)
                result = search_notes(args["query"])
            except Exception as exc:
                result = {"error": str(exc)}
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": json.dumps(result),
            })
    return "Stopped: step limit reached."

print(run("Which invoice is overdue?"))

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

การจัดการการตอบกลับ 429 และความพร้อมกัน

เอเจนต์ทำงานแบบเป็นช่วงๆ ผู้วางแผนอาจกระจายงานย่อยห้างานพร้อมกัน และแต่ละงานจะรันลูปของตัวเอง นี่คือจุดที่ขีดจำกัดอัตราปรากฏขึ้น

คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 รายการ และ 300 คำขอต่อนาที คีย์แบบทดลองอนุญาตให้ทำ 2 และ 60 เมื่อเลยขีดจำกัดแล้ว API จะตอบกลับด้วย HTTP 429 รหัสข้อผิดพลาดจะบอกคุณว่าคุณชนขีดจำกัดใด: rate_limited สำหรับคำขอต่อนาที และ concurrency สำหรับจำนวนที่มากเกินไปพร้อมกัน เมื่อเกิดภาวะโอเวอร์โหลดชั่วคราว คุณยังได้รับ 429 พร้อมส่วนหัว Retry-After: 5

จัดการทั้งหมดนี้เป็นการเรียกซ้ำ รอจำนวนวินาทีในส่วนหัว หรือสองสามวินาทีหากไม่มี แล้วส่งคำขออีกครั้ง คำขอที่ล้มเหลวไม่มีการเรียกเก็บเงิน ดังนั้นการเรียกซ้ำจึงไม่มีค่าใช้จ่าย ตัวห่อขนาดเล็กทำงานนี้

import time
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY", max_retries=0)

def chat_with_retry(**kwargs):
    for attempt in range(5):
        try:
            return client.chat.completions.create(model="uncensored", **kwargs)
        except RateLimitError as err:
            wait = 5
            if err.response is not None:
                wait = int(err.response.headers.get("retry-after", 5))
            time.sleep(wait)
    raise RuntimeError("Still rate limited after 5 attempts")

เพื่อหลีกเลี่ยง 429 ตั้งแต่แรก ให้จำกัดขนาดกลุ่ม worker เซมิโฟร์ (semaphore) ที่ 8 สอดคล้องกับคีย์เต็ม หากคุณสตรีม response ไปยัง UI จำไว้ว่าสตรีมจะครอบครอง slot concurrency จนกว่าโทเคนสุดท้ายจะมาถึง ดังนั้นไคลเอนต์ที่อ่านคำตอบยาวๆ จะครอบครอง slot ตลอดเวลา การอ่าน X-RateLimit-Limit-Requests และ X-RateLimit-Limit-Concurrency headers ช่วยให้โค้ดของคุณปรับตามคีย์ที่ใช้ได้

บริบท ความจำ และต้นทุนของการรัน

ทุกขั้นตอนของลูปจะส่ง transcript กลับทั้งหมด นั่นคือวิธีที่ chat APIs ทำงาน และหมายความว่าจำนวนโทเคนของอินพุตจะเพิ่มขึ้นในแต่ละการเรียกใช้ฟังก์ชัน ลองรันหกขั้นตอนที่เริ่มต้นที่ 2,000 โทเคน และเพิ่ม 1,000 โทเคนต่อขั้นตอน พร้อม output 300 โทเคนต่อขั้นตอน

  • โทเคนอินพุต: 2,000 + 3,000 + 4,000 + 5,000 + 6,000 + 7,000 = 27,000
  • โทเคนเอาต์พุต: 6 x 300 = 1,800
  • ต้นทุนอินพุต: 27,000 x 0.15 / 1,000,000 = $0.00405
  • ต้นทุนผลลัพธ์: 1,800 x 0.50 / 1,000,000 = $0.0009
  • รวม: $0.00495 ต่อการรัน

การรันแบบนั้น 1,000 ครั้ง ราคา $4.95 ซึ่งถูกพอให้ agent คิดหลายขั้นตอน แต่การเติบโตของจำนวนโทเคนควรเฝ้าระวัง ด้วยพื้นที่ 100,000 โทเคน agent ที่รันนานจะเติมหน้าต่างบริบทจนเต็มในที่สุด และ prompt ขนาดนั้นจะเสีย $0.015 สำหรับอินพุตในแต่ละขั้นตอน (100,000 x 0.15 / 1,000,000)

สามนิสัยนี้ช่วยควบคุมการใช้งานได้ ตัดทอนผลลัพธ์จากเครื่องมือ (tool results) ขนาดใหญ่ก่อนนำเข้าสู่บันทึกการสนทนา (transcript) เช่น ตัดเหลือเพียง 2,000 ตัวอักษรแรกของหน้าเว็บ สรุปขั้นตอนเก่าๆ ให้เหลือข้อความสั้นๆ หนึ่งข้อความเมื่อประวัติการสนทนาเกินเกณฑ์ที่กำหนด และเก็บข้อเท็จจริงที่คงทนถาวรไว้ในฐานข้อมูลของคุณเอง แทนที่จะพึ่งพาการสนทนาเป็นหน่วยความจำ

ส่วนหัว X-Balance-USD ในแต่ละการตอบกลับแสดงยอดเครดิตคงเหลือ ทำให้ผู้ควบคุมเอเจนต์สามารถหยุดการรันได้เมื่อยอดลดลงต่ำกว่าเกณฑ์ขั้นต่ำ เครดิตเป็นแบบเติมเงินล่วงหน้าเริ่มต้นที่ $20 และไม่มีวันหมดอายุ ดูโบนัสการเติมเงินที่ หน้ากำหนดราคา

ขีดจำกัดที่ชัดเจนสำหรับการวางแผน

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

  • อาร์กิวเมนต์ที่ผิดรูปแบบ โมเดลสามารถสร้างอาร์กิวเมนต์เครื่องมือที่ไม่ใช่ JSON ที่ถูกต้องหรือขาดฟิลด์ที่จำเป็น ให้แยกวิเคราะห์อย่างระมัดระวังและส่งข้อผิดพลาดเป็นผลลัพธ์ของเครื่องมือ
  • การเลือกเครื่องมือผิด เขียนคำอธิบายเครื่องมือให้สั้นและแตกต่างกัน หากเครื่องมือสองตัวคล้ายกัน โมเดลจะสับสน ใช้ tool_choice เพื่อบังคับการเรียกใช้เฉพาะเมื่อโฟลว์ต้องการ
  • ข้อความล้วนเท่านั้น ไม่รองรับการรับหรือส่งรูปภาพ ไม่มีเสียง ไม่มี embeddings และไม่มี fine-tuning ให้ดำเนินการส่วนเหล่านั้นที่อื่น แล้วส่งผลลัพธ์เป็นข้อความ
  • โมเดลเดียว มีโมเดลแบบเปิดน้ำหนักหนึ่งตัวที่อยู่หลังเอนด์พอยต์ ไม่ใช่ระบบเปลี่ยนเส้นทางข้ามผู้ขาย คุณไม่สามารถเลือกโมเดลที่เล็กลงสำหรับขั้นตอนง่ายๆ ได้
  • เครื่องมือที่ทำลายข้อมูล อย่ามอบเครื่องมือลบหรือชำระเงินให้เอเจนต์โดยไม่มีขั้นตอนยืนยันในโค้ดของคุณเอง

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

สุดท้าย บันทึกทุกขั้นตอน เก็บข้อความ อาร์กิวเมนต์เครื่องมือ และเฮดเดอร์ X-Request-Id จากการตอบกลับแต่ละครั้ง เมื่อการรันผิดพลาด รหัสคำขอช่วยให้คุณชี้ไปยังการเรียกใช้ที่เฉพาะเจาะจง และ transcript ที่บันทึกไว้แสดงว่าผลลัพธ์เครื่องมือใดทำให้โมเดลเข้าใจผิด เอเจนต์จะปรับปรุงได้ง่ายที่สุดเมื่อคุณสามารถเล่นซ้ำการรันที่ผิดพลาดและเปลี่ยนสิ่งเดียวในแต่ละครั้ง

ทดสอบเอเจนต์ด้วยเครดิตทดลองก่อนตัดสินใจ ผู้ใช้ใหม่สามารถรับเครดิต $0.50 ซึ่งในการรันหกขั้นตอนข้างต้นครอบคลุมการรันเต็มรูปแบบประมาณ 101 ครั้ง (0.50 / 0.00495) โปรดจำไว้ว่าเครดิตทดลองรองรับคำขอพร้อมกัน 2 คำขอ และรันเอเจนต์หนึ่งตัวต่อครั้ง เพื่อภาพรวมบริการที่กว้างขึ้น อ่าน ภาพรวมการจ่ายต่อโทเคน พรอมต์ไม่ถูกนำไปใช้สำหรับการฝึก

02

ถาม-ตอบ

API รองรับ function calling สำหรับเอเจนต์หรือไม่?

ใช่ API นี้รองรับการเรียกใช้เครื่องมือ โดยรับค่า tools และ tool_choice คืนค่า tool_calls (รวมถึงเมื่อใช้ streaming) และรับผลลัพธ์เป็น messages ที่มี role เป็น tool

เอเจนต์สามารถรันการเรียกใช้แบบขนานได้กี่ครั้ง?

คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 รายการ และ 300 รายการต่อนาที คีย์แบบทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 รายการ และ 60 รายการต่อนาที

เอเจนต์ควรทำอย่างไรเมื่อได้รับ 429?

รอค่า Retry-After หรือไม่กี่วินาทีหากไม่มี แล้วลองใหม่ คำขอที่ถูกปฏิเสธจะไม่มีการเรียกเก็บเงิน

เอเจนต์รองรับภาพหรือเสียงหรือไม่?

ไม่ โมเดลทำงานกับข้อความเท่านั้น ดังนั้นสื่ออื่นๆ ต้องถูกประมวลผลโดยเครื่องมือของคุณเองและส่งเข้ามาเป็นข้อความ

คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ และเปลี่ยน URL พื้นฐาน (base URL) นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API