Qwen 3.6 พร้อมใช้งานบน OpenRouter: วิธีใช้งานทันที

สรุปย่อ

Qwen 3.6 Plus Preview เปิดตัวเมื่อวันที่ 30 มีนาคม 2026 พร้อมกับ context window ขนาด 1 ล้านโทเค็น, การให้เหตุผลแบบ chain-of-thought ที่บังคับใช้, และการรองรับการใช้เครื่องมือ ตอนนี้ใช้งานได้ฟรีบน OpenRouter อย่างสมบูรณ์ ใช้ model ID qwen/qwen3.6-plus-preview:free กับไคลเอ็นต์ที่รองรับ OpenAI เพื่อเริ่มส่งคำขอได้เลยวันนี้

โมเดลที่ปรากฏตัวอย่างเงียบๆ

Alibaba Cloud ได้ปล่อย Qwen 3.6 Plus Preview เมื่อวันที่ 30 มีนาคม 2026 โดยไม่มีการประกาศใหญ่โต ไม่มีการรอคิว เป็นเพียงโมเดลใหม่ที่ใช้งานได้บน OpenRouter ในราคา $0 ต่อล้านโทเค็น

ในสองวันแรก โมเดลนี้ประมวลผลโทเค็นที่สมบูรณ์ไปกว่า 400 ล้านโทเค็น จากคำขอประมาณ 400,000 ครั้ง นักพัฒนาพบว่ามันทำงานได้รวดเร็ว

บทความนี้จะนำคุณไปสู่ทุกสิ่งที่คุณต้องการเพื่อเริ่มต้นใช้งาน: การตั้งค่าบัญชี, คีย์ API, ตัวอย่างโค้ดที่ใช้งานได้ใน cURL, Python และ Node.js รวมถึงคำแนะนำเฉพาะเกี่ยวกับจุดที่โมเดลนี้ทำงานได้ดีที่สุด

💡

หากคุณกำลังพัฒนาบน AI API ใดๆ คุณจะต้องการวิธีทดสอบและแก้ไขข้อผิดพลาดของคำขอเหล่านั้นได้อย่างน่าเชื่อถือ Apidog จัดการสิ่งนี้ได้ดี เป็นบริการฟรี และทำงานได้กับ REST API ทุกประเภท รวมถึง OpenRouter

ปุ่ม

เมื่อจบคู่มือนี้ คุณจะทราบได้อย่างชัดเจนถึงวิธีการเรียกใช้ Qwen 3.6 ได้ฟรี สิ่งที่มันสามารถทำได้ และข้อจำกัดของมัน

Qwen 3.6 เพิ่มอะไรบ้างจากซีรีส์ 3.5

การก้าวกระโดดจาก 3.5 ไป 3.6 ไม่ใช่การเพิ่มขึ้นทีละน้อย มีสามสิ่งที่เปลี่ยนแปลงไปอย่างมีความหมาย

1. Context window ขยายเป็น 1 ล้านโทเค็น

Qwen 3.5 มี context window ขนาด 32K ถึง 128K ขึ้นอยู่กับรุ่นย่อย ส่วน Qwen 3.6 รองรับอินพุต 1 ล้านโทเค็น

เพื่อให้เห็นภาพในทางปฏิบัติ: 1 ล้านโทเค็นมีค่าประมาณ 750,000 คำ ซึ่งเพียงพอที่จะป้อนโค้ดเบสทั้งหมด, บันทึก Slack หนึ่งปี, คลังเอกสารทางกฎหมายฉบับเต็ม, หรือชุดข้อมูลการวิจัยขนาดใหญ่ในการร้องขอครั้งเดียว

โมเดลฟรีส่วนใหญ่มีขีดจำกัดที่ 8K ถึง 32K การได้ 1M โทเค็นฟรีนั้นหาได้ยาก

2. การให้เหตุผลถูกสร้างขึ้นภายใน ไม่ใช่ทางเลือกเสริม

Qwen 3.6 ใช้โทเค็นการให้เหตุผลที่บังคับใช้ ก่อนที่โมเดลจะสร้างคำตอบสุดท้าย มันจะสร้างสายความคิดภายใน คุณไม่จำเป็นต้องกระตุ้นด้วย "คิดทีละขั้นตอน" หรือคำแนะนำพิเศษใดๆ

นี่เป็นรูปแบบเดียวกับที่ DeepSeek R1 ทำให้เป็นที่นิยม ความแตกต่างคือ Qwen 3.6 นำไปใช้กับงานการเขียนโค้ด, การพัฒนาส่วนหน้า (front-end), และงานแก้ปัญหาทั่วไป ไม่ใช่แค่คณิตศาสตร์

3. พฤติกรรมแบบเอเจนต์มีความน่าเชื่อถือมากขึ้น

การเรียกใช้เครื่องมือในซีรีส์ 3.5 ไม่สอดคล้องกัน ฟังก์ชันจะถูกเรียกด้วยประเภทอาร์กิวเมนต์ที่ไม่ถูกต้อง หรือโมเดลจะสร้างภาพหลอนการเรียกฟังก์ชันที่ไม่มีอยู่จริง

Qwen 3.6 แก้ไขปัญหานี้โดยตรง ตามคำอธิบายของ Alibaba Cloud เอง มัน "ให้การให้เหตุผลที่แข็งแกร่งขึ้นและพฤติกรรมแบบเอเจนต์ที่น่าเชื่อถือมากขึ้นเมื่อเทียบกับซีรีส์ 3.5" ในทางปฏิบัติ นี่หมายถึงการเรียกใช้เครื่องมือที่ผิดพลาดน้อยลงในเวิร์กโฟลว์หลายขั้นตอน

โมเดลนี้ได้รับการปรับแต่งเป็นพิเศษสำหรับสามงาน:

การเขียนโค้ดแบบเอเจนต์ (การสร้างโค้ดหลายขั้นตอนพร้อมการใช้เครื่องมือ)
การพัฒนาส่วนหน้า (front-end) (การสร้างส่วนประกอบ HTML, CSS, JavaScript)
การแก้ปัญหาที่ซับซ้อน (การวิจัย, การวิเคราะห์, การสรุปบริบทขนาดยาว)

วิธีเข้าถึง Qwen 3.6 ได้ฟรี

คุณต้องมีสองสิ่ง: บัญชี OpenRouter และคีย์ API ไม่ต้องใช้บัตรเครดิตสำหรับโมเดลฟรี

ขั้นตอนที่ 1: สร้างบัญชี OpenRouter ของคุณ

ไปที่ openrouter.ai และลงทะเบียนด้วยอีเมลหรือบัญชี Google กระบวนการทั้งหมดใช้เวลาไม่ถึงสองนาที

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

ขั้นตอนที่ 2: สร้างคีย์ API

คลิกที่รูปโปรไฟล์ของคุณที่มุมขวาบน
เลือก API Keys จากเมนูแบบเลื่อนลง
คลิก Create Key
ตั้งชื่อ (เช่น qwen-test) แล้วคลิก Create
คัดลอกคีย์ คีย์จะขึ้นต้นด้วย sk-or-v1-...

เก็บสิ่งนี้ไว้ในที่ปลอดภัย OpenRouter จะไม่แสดงให้คุณเห็นอีก

ขั้นตอนที่ 3: ส่งคำขอแรกของคุณ

Model ID คือ qwen/qwen3.6-plus-preview:free

OpenRouter ใช้รูปแบบคำขอเดียวกับ OpenAI API ดังนั้นไคลเอ็นต์ที่เข้ากันได้กับ OpenAI ใดๆ ก็สามารถใช้งานได้โดยไม่ต้องแก้ไข

cURL:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer sk-or-v1-YOUR_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3.6-plus-preview:free",
    "messages": [
      {
        "role": "user",
        "content": "เขียนฟังก์ชัน Python ที่แยกวิเคราะห์โทเค็น JWT และส่งคืน payload เป็น dictionary."
      }
    ]
  }'

Python (requests library):

import requests

def call_qwen(prompt: str, api_key: str) -> str:
    response = requests.post(
        "https://openrouter.ai/api/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        json={
            "model": "qwen/qwen3.6-plus-preview:free",
            "messages": [{"role": "user", "content": prompt}],
        },
        timeout=60,
    )
    response.raise_for_status()
    return response.json()["choices"][0]["message"]["content"]

result = call_qwen(
    "เขียนฟังก์ชัน Python ที่แยกวิเคราะห์โทเค็น JWT และส่งคืน payload.",
    api_key="sk-or-v1-YOUR_KEY_HERE"
)
print(result)

Node.js (fetch):

async function callQwen(prompt, apiKey) {
  const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "qwen/qwen3.6-plus-preview:free",
      messages: [{ role: "user", content: prompt }],
    }),
  });

  if (!response.ok) {
    throw new Error(`OpenRouter error: ${response.status} ${await response.text()}`);
  }

  const data = await response.json();
  return data.choices[0].message.content;
}

callQwen(
  "เขียนฟังก์ชัน JavaScript ที่ตรวจสอบความถูกต้องของที่อยู่อีเมล.",
  "sk-or-v1-YOUR_KEY_HERE"
).then(console.log);

Python with the OpenAI SDK:

หากคุณใช้ OpenAI Python SDK อยู่แล้ว คุณสามารถชี้ไปที่ OpenRouter ได้โดยไม่ต้องแก้ไขอะไรเลย:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-v1-YOUR_KEY_HERE",
)

response = client.chat.completions.create(
    model="qwen/qwen3.6-plus-preview:free",
    messages=[
        {
            "role": "system",
            "content": "คุณคือนักพัฒนาแบ็กเอนด์อาวุโส เขียนโค้ดที่สะอาดพร้อมใช้งานจริง"
        },
        {
            "role": "user",
            "content": "เขียนฟังก์ชัน Python ที่ลองส่งคำขอ HTTP ที่ล้มเหลวใหม่ได้สูงสุด 3 ครั้งพร้อมกับการหน่วงเวลาแบบ exponential backoff."
        }
    ],
)

print(response.choices[0].message.content)

การใช้เครื่องมือและเวิร์กโฟลว์แบบเอเจนต์

การใช้เครื่องมือคือจุดเด่นของ Qwen 3.6 ในระดับฟรี นี่คือตัวอย่างที่ใช้งานได้:

from openai import OpenAI
import json

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-v1-YOUR_KEY_HERE",
)

# Define the tools available to the model
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_api_docs",
            "description": "ค้นหาเอกสาร API สำหรับ endpoint หรือพารามิเตอร์ที่ต้องการ",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "The search query"
                    },
                    "version": {
                        "type": "string",
                        "enum": ["v1", "v2", "v3"],
                        "description": "เวอร์ชัน API ที่จะค้นหา"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_api_test",
            "description": "เรียกใช้คำขอทดสอบกับ API endpoint",
            "parameters": {
                "type": "object",
                "properties": {
                    "endpoint": {"type": "string"},
                    "method": {"type": "string", "enum": ["GET", "POST", "PUT", "DELETE"]},
                    "body": {"type": "object"}
                },
                "required": ["endpoint", "method"]
            }
        }
    }
]

messages = [
    {
        "role": "user",
        "content": "ค้นหาเอกสารสำหรับ endpoint /users และเรียกใช้คำขอ GET สำหรับการทดสอบ"
    }
]

response = client.chat.completions.create(
    model="qwen/qwen3.6-plus-preview:free",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

message = response.choices[0].message

# Check whether the model wants to call a tool
if message.tool_calls:
    for tool_call in message.tool_calls:
        print(f"เครื่องมือ: {tool_call.function.name}")
        args = json.loads(tool_call.function.arguments)
        print(f"อาร์กิวเมนต์: {json.dumps(args, indent=2)}")
else:
    print(message.content)

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

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

การใช้ context window ขนาด 1 ล้านโทเค็น

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

นี่คือสามรูปแบบที่สิ่งนี้มีความสำคัญอย่างแท้จริง:

การตรวจสอบโค้ดเบสทั้งหมด

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

import os
from pathlib import Path
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-v1-YOUR_KEY_HERE",
)

def load_codebase(directory: str, extensions: list[str]) -> str:
    """Load all source files from a directory into a single string."""
    content_parts = []
    for path in Path(directory).rglob("*"):
        if path.suffix in extensions and path.is_file():
            try:
                text = path.read_text(encoding="utf-8", errors="ignore")
                content_parts.append(f"--- FILE: {path} ---\n{text}\n")
            except Exception:
                continue
    return "\n".join(content_parts)

codebase = load_codebase("./src", [".py", ".js", ".ts"])

response = client.chat.completions.create(
    model="qwen/qwen3.6-plus-preview:free",
    messages=[
        {
            "role": "user",
            "content": f"ตรวจสอบโค้ดเบสนี้และระบุ:\n1. ช่องโหว่ด้านความปลอดภัย\n2. ฟังก์ชันที่ไม่มีการจัดการข้อผิดพลาด\n3. รูปแบบการตั้งชื่อที่ไม่สอดคล้องกัน\n\nโค้ดเบส:\n{codebase}"
        }
    ],
)

print(response.choices[0].message.content)

การวิเคราะห์เอกสารขนาดใหญ่

ป้อนเอกสารทางกฎหมายฉบับยาว, รายงานทางการเงิน, หรือเอกสารการวิจัย และถามคำถามเฉพาะเกี่ยวกับเอกสารเหล่านั้น

with open("annual_report_2025.txt", "r") as f:
    document = f.read()

response = client.chat.completions.create(
    model="qwen/qwen3.6-plus-preview:free",
    messages=[
        {
            "role": "user",
            "content": f"ดึงข้อมูลการกล่าวถึงข้อจำกัดอัตรา (rate limits) ของ API และการเปลี่ยนแปลงราคาทั้งหมดจากเอกสารนี้:\n\n{document}"
        }
    ],
)

การสนทนาหลายรอบพร้อมประวัติทั้งหมด

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

conversation = []

def chat(user_message: str) -> str:
    conversation.append({"role": "user", "content": user_message})
    
    response = client.chat.completions.create(
        model="qwen/qwen3.6-plus-preview:free",
        messages=conversation,
    )
    
    assistant_message = response.choices[0].message.content
    conversation.append({"role": "assistant", "content": assistant_message})
    return assistant_message

# Long back-and-forth debugging session
print(chat("ฉันได้รับข้อผิดพลาด 401 จาก GitHub API นี่คือโค้ดของฉัน..."))
print(chat("ฉันเพิ่มโทเค็นแล้วแต่ตอนนี้ได้รับ 403 โทเค็นมีขอบเขต repo."))
print(chat("repo เป็นส่วนตัว ฉันต้องการขอบเขตอะไรจริงๆ?"))

การทดสอบคำขอ OpenRouter API ด้วย Apidog

เมื่อคุณพัฒนาบน OpenRouter API การแก้ไขข้อผิดพลาดของคำขอที่ล้มเหลวจะกลายเป็นเรื่องน่าเบื่ออย่างรวดเร็ว คุณกำลังส่งคำขอ HTTP ตรวจสอบการตอบกลับ JSON และวนซ้ำพรอมต์ของคุณ การทำเช่นนี้จากบรรทัดคำสั่งหรือ Postman เป็นเรื่องช้า

Apidog น่าลองใช้ที่นี่ เป็นไคลเอ็นต์ API ฟรีที่จัดการการสร้างคำขอ, การตรวจสอบการตอบกลับ, และการทดสอบอัตโนมัติในที่เดียว

หากต้องการทดสอบ Qwen 3.6 endpoint ใน Apidog:

สร้างคำขอ POST ใหม่ไปยัง https://openrouter.ai/api/v1/chat/completions
เพิ่มส่วนหัว Authorization: Bearer sk-or-v1-... ของคุณ
ตั้งค่าเนื้อหาเป็น JSON พร้อมฟิลด์ model และ messages ของคุณ
ส่งคำขอและตรวจสอบการตอบกลับ

คุณสามารถบันทึกสิ่งนี้เป็นคอลเลกชัน สลับระหว่าง Model ID เพื่อเปรียบเทียบผลลัพธ์ และเขียนการทดสอบอัตโนมัติที่ตรวจสอบโครงสร้างการตอบกลับ ยืนยันว่า choices[0].message.content ไม่ว่างเปล่า หรือยืนยันว่าการเรียกใช้เครื่องมือมีชื่อฟังก์ชันที่คาดหวัง

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

ข้อจำกัดของระดับฟรีที่ควรรู้ก่อนนำไปสร้าง

Qwen 3.6 ใช้งานได้ฟรีในตอนนี้ ซึ่งจะไม่คงอยู่ตลอดไป และมีข้อจำกัดในทางปฏิบัติที่ต้องวางแผน

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

import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

session = requests.Session()
retry_strategy = Retry(
    total=3,
    backoff_factor=2,
    status_forcelist=[429, 500, 502, 503, 504],
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)

response = session.post(
    "https://openrouter.ai/api/v1/chat/completions",
    headers={"Authorization": "Bearer sk-or-v1-YOUR_KEY_HERE"},
    json={
        "model": "qwen/qwen3.6-plus-preview:free",
        "messages": [{"role": "user", "content": "Hello"}],
    },
    timeout=30,
)

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

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

ข้อความเท่านั้น Qwen 3.6 รับอินพุตข้อความและสร้างเอาต์พุตข้อความ ไม่มีรูปภาพ ไม่มีเสียง ไม่มีไฟล์อัปโหลด

กรณีการใช้งานจริง

การสร้างเอเจนต์ตรวจสอบโค้ด

ทีมที่สร้างเครื่องมือตรวจสอบ PR ภายใน ได้ป้อน diff ของ pull request ทั้งหมด (บางครั้งมากกว่า 10K บรรทัด) เข้าไปใน Qwen 3.6 และได้รับความคิดเห็นโดยละเอียดเกี่ยวกับข้อผิดพลาดทางตรรกะ, การทดสอบที่ขาดหายไป, และปัญหาด้านความปลอดภัย Context window ขนาด 1M โทเค็นทำให้สามารถทำได้โดยไม่ต้องแบ่งส่วนข้อมูล

การสร้างส่วนประกอบ Front-end

นักพัฒนาเดี่ยวที่สร้างแดชบอร์ด SaaS ใช้ Qwen 3.6 เพื่อสร้างส่วนประกอบ React จากข้อกำหนดการออกแบบ โมเดลสร้าง TypeScript ที่สะอาดพร้อมประเภทพร็อพที่ถูกต้องและ CSS ที่ตอบสนองได้โดยไม่ต้องมีการแก้ไขหลายครั้ง

การสรุปเอกสาร API

ทีมที่ย้ายข้อมูลระหว่าง API การชำระเงินของบุคคลที่สาม ได้ป้อนเอกสารฉบับเต็มของ API ทั้งสอง (แต่ละฉบับประมาณ 100K โทเค็น) ในคำขอเดียว และขอให้เปรียบเทียบวิธีการยืนยันตัวตน, รูปแบบ webhook, และข้อจำกัดอัตราการใช้งานแบบเคียงข้างกัน โมเดลส่งคืนตารางที่มีโครงสร้างภายใน 30 วินาที

ลงทะเบียนที่ openrouter.ai รับคีย์ของคุณ แล้วเปลี่ยนไปใช้ qwen/qwen3.6-plus-preview:free แทนโมเดลใดๆ ที่คุณกำลังจ่ายเงินอยู่

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

Qwen 3.6 ใช้งานได้ฟรีจริงหรือไม่?

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

ข้อจำกัดอัตราการใช้งานสำหรับระดับฟรีคืออะไร?

OpenRouter ไม่ได้เผยแพร่ข้อจำกัดอัตราการใช้งานที่แน่นอนสำหรับโมเดลระดับฟรี ในทางปฏิบัติ โมเดลฟรีจะแชร์ความจุและอาจถูกจำกัดความเร็วในช่วงที่มีการเข้าชมสูง เริ่มต้นด้วยการส่งคำขอทีละหนึ่งครั้งและเพิ่มตรรกะการลองใหม่ (retry logic) ก่อนที่จะเพิ่มการทำงานพร้อมกัน

ฉันสามารถใช้ Qwen 3.6 สำหรับโครงการเชิงพาณิชย์ได้หรือไม่?

ได้ OpenRouter อนุญาตให้ใช้ในเชิงพาณิชย์ ตรวจสอบใบอนุญาตโมเดล Qwen ของ Alibaba Cloud สำหรับข้อจำกัดใดๆ ในตัวโมเดลเอง โดยเฉพาะอย่างยิ่งหากคุณกำลังแจกจ่ายผลลัพธ์

ทำไม Qwen 3.6 ถึงใช้เวลาตอบสนองนานกว่าโมเดลอื่น?

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

มีวิธีปิดใช้งานโทเค็นการให้เหตุผลหรือไม่?

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

context window ขนาด 1M โทเค็นส่งผลต่อค่าใช้จ่ายอย่างไร?

สำหรับระดับฟรี มันไม่ส่งผลกระทบ คุณจ่าย $0 ไม่ว่าคุณจะส่งโทเค็นไปเท่าไรก็ตาม โปรดทราบว่าคำขอที่มีขนาดใหญ่มากจะใช้เวลาประมวลผลนานขึ้นและอาจหมดเวลา (time out) ในระดับฟรี เริ่มต้นด้วยการตั้งเวลาหมด (timeout) 30-60 วินาที และเพิ่มขึ้นสำหรับคำขอที่เกิน 100K โทเค็น

ปุ่ม