รู้จัก Switchyard: ไลบรารี Open Source จาก NVIDIA ที่ช่วยจัดการเส้นทาง LLM เพื่อลดต้นทุน

ปัจจุบัน AI agent ส่วนใหญ่มักส่งคำขอทุกประเภทไปยังโมเดลระดับแนวหน้า (Frontier Model) ที่มีราคาสูงเสมอ ไม่ว่าจะเป็นงานง่ายๆ อย่างการแยกประเภท (Classification) ไปจนถึงการใช้เหตุผลที่ซับซ้อน ส่งผลให้เกิดต้นทุนและความหน่วงที่เกินความจำเป็น NVIDIA NeMo Switchyard จึงถูกพัฒนาขึ้นมาเพื่อแก้ปัญหานี้โดยเฉพาะ

Switchyard ทำหน้าที่เป็นเลเยอร์การกำหนดเส้นทางแบบ Open-source (Proxy + Library) ที่คั่นกลางระหว่าง Agent และโมเดล โดยจะตัดสินใจแบบเรียลไทม์ว่าคำขอใดควรส่งไปยังโมเดลใด ในบทความนี้เราจะสร้างเราเตอร์แบบสองโมเดล เพื่อเรียนรู้การพัฒนาจากการกำหนดเส้นทางแบบสุ่ม (Random Routing) ไปสู่การกำหนดเส้นทางตามเนื้อหา (Content-aware Routing)

Switchyard ทำหน้าที่อะไรกันแน่? โดยปกติแอปพลิเคชัน LLM จะเชื่อมต่อกับโมเดลโดยตรง แต่ Switchyard จะเพิ่มเลเยอร์ตรงกลางเพื่อคัดกรองคำขอ:

Application
    |
    v
Switchyard
   /   \
  v     v
Cheap   Powerful
Model   Model

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

ขั้นตอนที่ 1: การติดตั้ง Switchyard

สำหรับการใช้งานผ่าน CLI หรือ Server สามารถติดตั้งผ่าน uv ได้ด้วยคำสั่ง:

uv tool install "nemo-switchyard[cli,server]"

ตรวจสอบความถูกต้องของการติดตั้ง:

switchyard --version

ผลลัพธ์:

switchyard 0.2.0
nemo-switchyard v0.2.0

นอกจากนี้ยังสามารถติดตั้ง Native Rust Server ได้โดยตรงผ่าน Cargo:

cargo install --locked switchyard-server

ในบทช่วยสอนนี้เราจะกำหนดเส้นทางผ่าน OpenRouter ดังนั้นต้องทำการ Export API Key ก่อน (ห้ามบันทึก Key ลงในไฟล์กำหนดค่าโดยตรง):

export OPENROUTER_API_KEY="your-key-here"

ขั้นตอนที่ 2: การกำหนดค่า Switchyard เบื้องต้น

เราจะเริ่มจากการตั้งค่าแบบสุ่ม (Random Routing) ระหว่างสองโมเดล โดยสร้างไฟล์ routes.random.yaml ดังนี้:

defaults:
  base_url: https://openrouter.ai/api/v1
  api_key: ${OPENROUTER_API_KEY}
 
routes:
  ab-test:
    type: random_routing
 
strong:
      model: openai/gpt-4o
 
weak:
      model: openai/gpt-4o-mini
 
strong_probability: 0.3
    rng_seed: 42
    fallback_target_on_evict: weak

การตั้งค่า strong_probability: 0.3 หมายถึง Switchyard จะส่งคำขอไปยังโมเดลตัวแรง (Strong) 30% และโมเดลขนาดเล็ก (Weak) 70% ซึ่งมีประโยชน์มากสำหรับการทำ A/B Testing เพื่อทดสอบระบบก่อนเริ่มใช้งานจริง

ขั้นตอนที่ 3: การเริ่มเซิร์ฟเวอร์กำหนดเส้นทาง

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

switchyard serve \
  -c routes.random.yaml \
  --host 127.0.0.1 \
  --port 4000

ตรวจสอบสถานะการทำงานของ Proxy:

curl -s http://127.0.0.1:4000/health

ผลลัพธ์:

{"status":"ok"}

ขั้นตอนที่ 4: การส่งคำขอผ่านเราเตอร์

ลองส่งคำขอในรูปแบบ API ของ OpenAI โดยระบุโมเดลเป็นชื่อโปรไฟล์ที่เราตั้งไว้:

curl http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"ab-test","messages":[{"role":"user","content":"Explain gradient descent in simple terms."}]}'

ในตัวอย่างนี้ ระบบจะเลือกส่งคำไปยังโมเดลขนาดเล็ก (Weak Tier) โดยอัตโนมัติ:

"model": "openai/gpt-4o-mini",
"usage": { "prompt_tokens": 14, "completion_tokens": 247, "cost": 0.0001503 }

ขั้นตอนที่ 5: การอัปเกรดเป็นการกำหนดเส้นทางอัจฉริยะ เพื่อให้ระบบฉลาดขึ้น เราจะใช้ classifier เพื่อประเมินว่าคำขอใดต้องการพลังจากโมเดลระดับสูง โดยสร้างไฟล์ routes.smart.yaml:

defaults:
  base_url: https://openrouter.ai/api/v1
  api_key: ${OPENROUTER_API_KEY}
 
routes:
  smart:
    type: deterministic
 
classifier:
      model: openai/gpt-4o-mini
 
strong:
      model: openai/gpt-4o
 
weak:
      model: openai/gpt-4o-mini
 
profile: general
    session_affinity: true
    fallback_target_on_evict: weak

ตัว Classifier จะประเมินค่า p_solve เพื่อทำนายว่าโมเดลขนาดเล็กสามารถจัดการคำขอนั้นๆ ได้หรือไม่ หากไม่ได้ก็จะส่งต่อไปยังโมเดลตัวแรงแทน

ขั้นตอนที่ 6: การทดสอบเส้นทางอัจฉริยะ (Smart Route)

เมื่อทดสอบด้วยคำถามง่ายๆ อย่างคณิตศาสตร์พื้นฐาน ระบบจะใช้โมเดลราคาถูก แต่เมื่อเจอคำถามด้านเทคนิคที่ซับซ้อน เช่น การออกแบบ Distributed Job Queue เพื่อเลี่ยง Race Condition ระบบจะสลับไปใช้โมเดลตัวแรงโดยอัตโนมัติ

ขั้นตอนที่ 7: การกำหนดเส้นทาง Coding Agent ตามความคืบหน้า

สำหรับงานที่มีหลายขั้นตอน (Multi-turn) อย่าง Coding Agent นั้น Switchyard มี stage_router เพื่อประหยัด Inference Budget โดยจะประเมินจากความคืบหน้าของบทสนทนา เช่น ในเทิร์นแรกๆ ที่เป็นการสำรวจไฟล์อาจใช้โมเดลประหยัด และจะยกระดับขึ้นเมื่อต้องการความสามารถพิเศษ

routes:
  stage:
    type: stage_router
    strong:
      model: openai/gpt-4o
    weak:
      model: openai/gpt-4o-mini
    picker: efficient_first
    confidence_threshold: 0.5
    signal_recent_window: 3
    fallback_target_on_evict: weak

ขั้นตอนที่ 8: การยกระดับเฉพาะเมื่อโมเดลระดับ Weak เริ่มมีปัญหา

อีกกลยุทธ์คือ Escalation Routing ซึ่งจะให้โมเดลราคาถูกลองทำก่อน หากระบบตรวจสอบพบสัญญาณว่าโมเดลกำลังประสบปัญหา (เช่น ตอบผิดซ้ำซาก) จึงค่อยยกระดับส่งต่อให้โมเดลระดับสูงจัดการต่อ

routes:
  agent:
    type: escalation_router
    strong:
      model: openai/gpt-4o
    weak:
      model: openai/gpt-4o-mini
    judge:
      model: openai/gpt-4o-mini
      confirmations: 2
      recent_turn_window: 28
      window_message_chars: 500
    fallback_target_on_evict: weak

ขั้นตอนที่ 9: การวัดผลความคุ้มค่า

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

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