ผู้ให้บริการ

ใช้ผู้ให้บริการ LLM ใน OpenCode

OpenCode ใช้ AI SDK และ Models.dev เพื่อรองรับผู้ให้บริการ 75+ LLM และรองรับการใช้งานโมเดลท้องถิ่น

หากต้องการเพิ่มผู้ให้บริการ คุณต้อง:

เพิ่มคีย์ API สำหรับผู้ให้บริการโดยใช้คำสั่ง /connect
กำหนดค่าผู้ให้บริการในการกำหนดค่า OpenCode ของคุณ

ข้อมูลรับรอง

เมื่อคุณเพิ่มคีย์ API ของผู้ให้บริการด้วยคำสั่ง /connect คีย์เหล่านั้นจะถูกเก็บไว้ ใน ~/.local/share/opencode/auth.json.

การกำหนดค่า

คุณสามารถปรับแต่งผู้ให้บริการได้ผ่านทางส่วน provider ใน OpenCode ของคุณ กำหนดค่า

Base URL

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

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "baseURL": "https://api.anthropic.com/v1"
      }
    }
  }
}

OpenCode Zen

OpenCode Zen คือรายชื่อโมเดลที่จัดทำโดยทีมงาน OpenCode ที่ได้รับ ทดสอบและตรวจสอบแล้วว่าทำงานได้ดีกับ OpenCode เรียนรู้เพิ่มเติม

เรียกใช้คำสั่ง /connect ใน TUI เลือก opencode และไปที่ opencode.ai/auth
```
/connect
```
ลงชื่อเข้าใช้ เพิ่มรายละเอียดการเรียกเก็บเงินของคุณ และคัดลอกรหัส API ของคุณ
วางคีย์ API ของคุณ
```
┌ API key
│
│
└ enter
```
เรียกใช้ /models ใน TUI เพื่อดูรายการรุ่นที่เราแนะนำ
```
/models
```

มันทำงานเหมือนกับผู้ให้บริการรายอื่นใน OpenCode และเป็นทางเลือกในการใช้งานโดยสมบูรณ์

ไดเรกทอรี

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

302.AI

ไปที่ 302.AI console สร้างบัญชี และสร้างคีย์ API
เรียกใช้คำสั่ง /connect และค้นหา 302.AI
```
/connect
```
ป้อนคีย์ 302.AI API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่น
```
/models
```

Amazon Bedrock

วิธีใช้ Amazon Bedrock กับ OpenCode:

ไปที่ แค็ตตาล็อกโมเดล ในคอนโซล Amazon Bedrock และขอ เข้าถึงโมเดลที่คุณต้องการ

คุณต้องมีสิทธิ์เข้าถึงโมเดลที่คุณต้องการใน Amazon Bedrock
กำหนดค่าการตรวจสอบสิทธิ์ โดยใช้วิธีใดวิธีหนึ่งต่อไปนี้:

ตัวแปรสภาพแวดล้อม (เริ่มต้นอย่างรวดเร็ว)

ตั้งค่าหนึ่งในตัวแปรสภาพแวดล้อมเหล่านี้ขณะเรียกใช้ opencode:
Terminal window
```
# Option 1: Using AWS access keys
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

# Option 2: Using named AWS profile
AWS_PROFILE=my-profile opencode

# Option 3: Using Bedrock bearer token
AWS_BEARER_TOKEN_BEDROCK=XXX opencode
```
หรือเพิ่มลงในโปรไฟล์ทุบตีของคุณ:
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
ไฟล์การกำหนดค่า (แนะนำ)

สำหรับการกำหนดค่าเฉพาะโครงการหรือแบบถาวร ให้ใช้ opencode.json:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "my-aws-profile"
      }
    }
  }
}
```
ตัวเลือกที่มี:
- region - AWS ภูมิภาค (เช่น us-east-1, eu-west-1)
- profile - AWS ตั้งชื่อโปรไฟล์จาก ~/.aws/credentials
- endpoint - จุดสิ้นสุดที่กำหนดเอง URL สำหรับ VPC จุดสิ้นสุด (นามแฝงสำหรับตัวเลือก baseURL ทั่วไป)
ตัวเลือกไฟล์การกำหนดค่ามีความสำคัญเหนือกว่าตัวแปรสภาพแวดล้อม

ขั้นสูง: VPC จุดสิ้นสุด

หากคุณใช้จุดสิ้นสุด VPC สำหรับ Bedrock:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "production",
        "endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
      }
    }
  }
}
```
ตัวเลือก endpoint เป็นนามแฝงสำหรับตัวเลือก baseURL ทั่วไป โดยใช้คำศัพท์เฉพาะ AWS หากมีการระบุทั้ง endpoint และ baseURL endpoint จะมีความสำคัญเหนือกว่า

วิธีการรับรองความถูกต้อง
- AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY: สร้างผู้ใช้ IAM และสร้างคีย์การเข้าถึงในคอนโซล AWS
- AWS_PROFILE: ใช้โปรไฟล์ที่มีชื่อจาก ~/.aws/credentials ขั้นแรกให้กำหนดค่าด้วย aws configure --profile my-profile หรือ aws sso login
- AWS_BEARER_TOKEN_BEDROCK: สร้างคีย์ API ระยะยาวจากคอนโซล Amazon Bedrock
- AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN: สำหรับ EKS IRSA (IAM บทบาทสำหรับบัญชีบริการ) หรือสภาพแวดล้อม Kubernetes อื่นๆ ที่มีการเชื่อมโยง OIDC Kubernetes แทรกตัวแปรสภาพแวดล้อมเหล่านี้โดยอัตโนมัติเมื่อใช้คำอธิบายประกอบของบัญชีบริการ
ลำดับความสำคัญของการรับรองความถูกต้อง

Amazon Bedrock ใช้ลำดับความสำคัญในการรับรองความถูกต้องต่อไปนี้:
1. Bearer Token - AWS_BEARER_TOKEN_BEDROCK ตัวแปรสภาพแวดล้อมหรือโทเค็นจากคำสั่ง /connect
2. AWS Credential Chain - โปรไฟล์, คีย์การเข้าถึง, ข้อมูลประจำตัวที่แชร์, บทบาท IAM, โทเค็นข้อมูลประจำตัวของเว็บ (EKS IRSA), ข้อมูลเมตาของอินสแตนซ์
เมื่อตั้งค่าBearer Token (ผ่าน /connect หรือ AWS_BEARER_TOKEN_BEDROCK) โทเค็นนั้นจะมีความสำคัญเหนือกว่าวิธีการข้อมูลประจำตัว AWS ทั้งหมด รวมถึงโปรไฟล์ที่กำหนดค่าไว้
รันคำสั่ง /models เพื่อเลือกรุ่นที่ต้องการ
```
/models
```

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

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      // ...
      "models": {
        "anthropic-claude-sonnet-4.5": {
          "id": "arn:aws:bedrock:us-east-1:xxx:application-inference-profile/yyy"
        }
      }
    }
  }
}

Anthropic

เมื่อคุณสมัครแล้ว ให้รันคำสั่ง /connect และเลือก Anthropic
```
/connect
```
ที่นี่คุณสามารถเลือกตัวเลือก Claude Pro/Max และมันจะเปิดเบราว์เซอร์ของคุณ และขอให้คุณตรวจสอบสิทธิ์
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
ตอนนี้โมเดล Anthropic ทั้งหมดควรจะพร้อมใช้งานเมื่อคุณใช้คำสั่ง /models
```
/models
```

การใช้การสมัครสมาชิก Claude Pro/Max ใน OpenCode ไม่ได้รับการสนับสนุนอย่างเป็นทางการจาก Anthropic

ใช้API Key

คุณยังสามารถเลือก สร้าง API คีย์ หากคุณไม่มีการสมัครสมาชิก Pro/Max นอกจากนี้ยังจะเปิดเบราว์เซอร์ของคุณและขอให้คุณเข้าสู่ระบบ Anthropic และให้รหัสที่คุณสามารถวางใน terminal ของคุณ

หรือหากคุณมีคีย์ API อยู่แล้ว คุณสามารถเลือก ป้อนคีย์ API ด้วยตนเอง และวางลงใน terminal ของคุณ

Azure OpenAI

ไปที่ พอร์ทัล Azure และสร้างทรัพยากร Azure OpenAI คุณจะต้องการ:
- ชื่อทรัพยากร: นี่จะกลายเป็นส่วนหนึ่งของจุดสิ้นสุด API ของคุณ (https://RESOURCE_NAME.openai.azure.com/)
- API key: KEY 1 หรือ KEY 2 จากทรัพยากรของคุณ
ไปที่ Azure AI Foundry และปรับใช้โมเดล

ชื่อการปรับใช้จะต้องตรงกับชื่อรุ่นเพื่อให้ opencode ทำงานได้อย่างถูกต้อง
เรียกใช้คำสั่ง /connect และค้นหา Azure
```
/connect
```
ป้อน API ของคุณ
```
┌ API key
│
│
└ enter
```
ตั้งชื่อทรัพยากรของคุณเป็นตัวแปรสภาพแวดล้อม:
Terminal window
```
AZURE_RESOURCE_NAME=XXX opencode
```
หรือเพิ่มลงในโปรไฟล์ทุบตีของคุณ:
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
รันคำสั่ง /models เพื่อเลือกโมเดลที่ปรับใช้ของคุณ
```
/models
```

บริการความรู้ความเข้าใจ Azure

ไปที่ พอร์ทัล Azure และสร้างทรัพยากร Azure OpenAI คุณจะต้องการ:
- ชื่อทรัพยากร: นี่จะกลายเป็นส่วนหนึ่งของจุดสิ้นสุด API ของคุณ (https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/)
- API key: KEY 1 หรือ KEY 2 จากทรัพยากรของคุณ
ไปที่ Azure AI Foundry และปรับใช้โมเดล

ชื่อการปรับใช้จะต้องตรงกับชื่อรุ่นเพื่อให้ opencode ทำงานได้อย่างถูกต้อง
เรียกใช้คำสั่ง /connect และค้นหา Azure Cognitive Services
```
/connect
```
ป้อน API ของคุณ
```
┌ API key
│
│
└ enter
```
ตั้งชื่อทรัพยากรของคุณเป็นตัวแปรสภาพแวดล้อม:
Terminal window
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
หรือเพิ่มลงในโปรไฟล์ทุบตีของคุณ:
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
รันคำสั่ง /models เพื่อเลือกโมเดลที่ปรับใช้ของคุณ
```
/models
```

บาสเตน

ไปที่ Baseten สร้างบัญชี และสร้างคีย์ API
รันคำสั่ง /connect และค้นหา Baseten
```
/connect
```
ป้อนคีย์ Baseten API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่น
```
/models
```

Cerebras

ไปที่ คอนโซล Cerebras สร้างบัญชี และสร้างคีย์ API
เรียกใช้คำสั่ง /connect และค้นหา Cerebras
```
/connect
```
ป้อนคีย์ Cerebras API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่นเช่น Qwen 3 Coder 480B
```
/models
```

Cloudflare AI Gateway ช่วยให้คุณเข้าถึงโมเดลจาก OpenAI, Anthropic, Workers AI และอื่นๆ อีกมากมายผ่านตำแหน่งข้อมูลแบบรวม ด้วย การเรียกเก็บเงินแบบรวม คุณไม่จำเป็นต้องใช้คีย์ API แยกต่างหากสำหรับผู้ให้บริการแต่ละราย

ไปที่ แดชบอร์ด Cloudflare ไปที่ AI > เกตเวย์ AI และสร้างเกตเวย์ใหม่
ตั้งค่ารหัสบัญชีและรหัสเกตเวย์ของคุณเป็นตัวแปรสภาพแวดล้อม
~/.bash_profile
```
export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id
```
รันคำสั่ง /connect และค้นหา Cloudflare AI Gateway
```
/connect
```
ป้อน Cloudflare API Token ของคุณ
```
┌ API key
│
│
└ enter
```
หรือตั้งเป็นตัวแปรสภาพแวดล้อม
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

รันคำสั่ง /models เพื่อเลือกรุ่น

/models

คุณยังสามารถเพิ่มโมเดลผ่านการกำหนดค่า opencode ของคุณได้

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "cloudflare-ai-gateway": {
      "models": {
        "openai/gpt-4o": {},
        "anthropic/claude-sonnet-4": {}
      }
    }
  }
}

คอร์เทคส์

ไปที่ คอนโซล Cortecs สร้างบัญชี และสร้างคีย์ API
เรียกใช้คำสั่ง /connect และค้นหา Cortecs
```
/connect
```
ป้อนคีย์ Cortecs API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น Kimi K2 Instruct
```
/models
```

ดีปซีค

ไปที่ คอนโซล DeepSeek สร้างบัญชี แล้วคลิก สร้างคีย์ API ใหม่
รันคำสั่ง /connect และค้นหา DeepSeek
```
/connect
```
ป้อนคีย์ DeepSeek API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดล DeepSeek เช่น DeepSeek Reasoner
```
/models
```

Deep Infra

ไปที่ แดชบอร์ด Deep Infra สร้างบัญชี และสร้างคีย์ API
เรียกใช้คำสั่ง /connect และค้นหา Deep Infra
```
/connect
```
ป้อนคีย์ Deep Infra API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่น
```
/models
```

Firmware

ไปที่ แดชบอร์ดเฟิร์มแวร์ สร้างบัญชี และสร้างคีย์ API
เรียกใช้คำสั่ง /connect และค้นหา เฟิร์มแวร์
```
/connect
```
ป้อนคีย์เฟิร์มแวร์ API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่น
```
/models
```

Fireworks AI

ไปที่ คอนโซล AI ดอกไม้ไฟ สร้างบัญชี แล้วคลิก สร้าง API คีย์
รันคำสั่ง /connect และค้นหา Fireworks AI
```
/connect
```
ป้อนคีย์ดอกไม้ไฟ AI API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น Kimi K2 Instruct
```
/models
```

GitLab Duo

GitLab Duo ให้การแชทแบบเอเจนต์ที่ขับเคลื่อนด้วย AI พร้อมความสามารถในการเรียกใช้เครื่องมือแบบเนทีฟผ่านพร็อกซี Anthropic ของ GitLab

รันคำสั่ง /connect และเลือก GitLab
```
/connect
```
เลือกวิธีการรับรองความถูกต้องของคุณ:
```
┌ Select auth method
│
│ OAuth (Recommended)
│ Personal Access Token
└
```
การใช้ OAuth (แนะนำ)

เลือก OAuth และเบราว์เซอร์ของคุณจะเปิดขึ้นเพื่อรับสิทธิ์

Using Personal Access Token

ไปที่ GitLab User Settings > Access Tokens
คลิก เพิ่มโทเค็นใหม่
ชื่อ: OpenCode, ขอบเขต: api
คัดลอกโทเค็น (เริ่มต้นด้วย glpat-)
ป้อนลงใน terminal
รันคำสั่ง /models เพื่อดูรุ่นที่มีจำหน่าย
```
/models
```
มีโมเดลที่ใช้ Claude สามรุ่นให้เลือก:
- duo-chat-haiku-4-5 (ค่าเริ่มต้น) - ตอบสนองรวดเร็วสำหรับงานด่วน
- duo-chat-sonnet-4-5 - ประสิทธิภาพที่สมดุลสำหรับขั้นตอนการทำงานส่วนใหญ่
- duo-chat-opus-4-5 - มีความสามารถมากที่สุดสำหรับการวิเคราะห์ที่ซับซ้อน

GitLab ที่โฮสต์เอง

OpenCode ใช้โมเดลขนาดเล็กสำหรับงาน AI บางอย่าง เช่น การสร้างชื่อเซสชัน มีการกำหนดค่าให้ใช้ gpt-5-nano ตามค่าเริ่มต้น ซึ่งโฮสต์โดย Zen เพื่อล็อค OpenCode หากต้องการใช้เฉพาะอินสแตนซ์ที่โฮสต์บน GitLab ของคุณเอง ให้เพิ่มสิ่งต่อไปนี้ในของคุณ opencode.json ไฟล์. ขอแนะนำให้ปิดใช้งานการแชร์เซสชันด้วย

{
  "$schema": "https://opencode.ai/config.json",
  "small_model": "gitlab/duo-chat-haiku-4-5",
  "share": "disabled"
}

สำหรับอินสแตนซ์ GitLab ที่โฮสต์เอง:

export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_TOKEN=glpat-...

หากอินสแตนซ์ของคุณใช้งาน AI Gateway แบบกำหนดเอง:

GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com

หรือเพิ่มในโปรไฟล์ทุบตีของคุณ:

export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
export GITLAB_TOKEN=glpat-...

OAuth สำหรับอินสแตนซ์ที่โฮสต์เอง

คุณต้องสร้างเพื่อให้ Oauth ทำงานกับอินสแตนซ์ที่โฮสต์เองได้ แอพพลิเคชั่นใหม่ (Settings → Applications) ด้วย โทรกลับ URL http://127.0.0.1:8080/callback และขอบเขตต่อไปนี้:

api (เข้าถึง API ในนามของคุณ)
read_user (อ่านข้อมูลส่วนตัวของคุณ)
read_repository (อนุญาตให้เข้าถึงที่เก็บแบบอ่านอย่างเดียว)

จากนั้นเปิดเผย ID แอปพลิเคชันเป็นตัวแปรสภาพแวดล้อม:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

เอกสารประกอบเพิ่มเติมเกี่ยวกับหน้าแรกของ opencode-gitlab-auth

การกำหนดค่า

ปรับแต่งผ่าน opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com",
        "featureFlags": {
          "duo_agent_platform_agentic_chat": true,
          "duo_agent_platform": true
        }
      }
    }
  }
}

GitLab API Tools (เป็นทางเลือก แต่แนะนำเป็นอย่างยิ่ง)

วิธีเข้าถึงเครื่องมือ GitLab (รวมคำขอ ปัญหา ไปป์ไลน์ CI/CD ฯลฯ):

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["@gitlab/opencode-gitlab-plugin"]
}

ปลั๊กอินนี้มอบความสามารถในการจัดการพื้นที่เก็บข้อมูล GitLab ที่ครอบคลุม รวมถึงการตรวจสอบ MR การติดตามปัญหา การตรวจสอบไปป์ไลน์ และอื่นๆ

GitHub Copilot

วิธีใช้การสมัครสมาชิก GitHub Copilot ด้วย opencode:

รันคำสั่ง /connect และค้นหา GitHub Copilot
```
/connect
```

ไปที่ github.com/login/device และป้อนรหัส

┌ Login with GitHub Copilot
│
│ https://github.com/login/device
│
│ Enter code: 8F43-6FCF
│
└ Waiting for authorization...

ตอนนี้รันคำสั่ง /models เพื่อเลือกรุ่นที่คุณต้องการ
```
/models
```

กูเกิล เวอร์เท็กซ์ เอไอ

วิธีใช้ Google Vertex AI กับ OpenCode:

ไปที่ Model Garden ใน Google Cloud Console แล้วตรวจสอบ รุ่นที่มีในภูมิภาคของคุณ

คุณต้องมีโปรเจ็กต์ Google Cloud ที่เปิดใช้งาน Vertex AI API
ตั้งค่าตัวแปรสภาพแวดล้อมที่ต้องการ:
- GOOGLE_CLOUD_PROJECT: รหัสโครงการ Google Cloud ของคุณ
- VERTEX_LOCATION (เป็นทางเลือก): ภูมิภาคสำหรับ Vertex AI (ค่าเริ่มต้นคือ global)
- การรับรองความถูกต้อง (เลือกหนึ่งรายการ):
  - GOOGLE_APPLICATION_CREDENTIALS: เส้นทางไปยังบัญชีบริการของคุณ JSON ไฟล์คีย์
  - ตรวจสอบสิทธิ์โดยใช้ gcloud CLI: gcloud auth application-default login
ตั้งค่าในขณะที่เรียกใช้ opencode
Terminal window
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
หรือเพิ่มลงในโปรไฟล์ทุบตีของคุณ
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

รันคำสั่ง /models เพื่อเลือกรุ่นที่ต้องการ
```
/models
```

Groq

ไปที่ Groq console คลิก Create API Key และคัดลอกคีย์
เรียกใช้คำสั่ง /connect และค้นหา Groq
```
/connect
```
ป้อนคีย์ API สำหรับผู้ให้บริการ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกคำสั่งที่คุณต้องการ
```
/models
```

Hugging Face

ผู้ให้บริการการอนุมานHugging Face ช่วยให้สามารถเข้าถึงโมเดลแบบเปิดที่รองรับโดยผู้ให้บริการมากกว่า 17 ราย

ไปที่ การตั้งค่าHugging Face เพื่อสร้างโทเค็นที่มีสิทธิ์ในการโทรไปยังผู้ให้บริการการอนุมาน
เรียกใช้คำสั่ง /connect และค้นหา Hugging Face
```
/connect
```
ป้อน Hugging Face Token ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดล เช่น Kimi-K2-Instruct หรือ GLM-4.6
```
/models
```

เฮลิโคน

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

ไปที่ Helicone สร้างบัญชี และสร้างคีย์ API จากแดชบอร์ดของคุณ
รันคำสั่ง /connect และค้นหา Helicone
```
/connect
```
ป้อนคีย์ Helicone API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่น
```
/models
```

หากต้องการทราบผู้ให้บริการเพิ่มเติมและฟีเจอร์ขั้นสูง เช่น การแคชและการจำกัดอัตรา โปรดตรวจสอบ เอกสารประกอบของ Helicone

การกำหนดค่าเพิ่มเติม

ในกรณีที่คุณเห็นคุณสมบัติหรือรุ่นจาก Helicone ที่ไม่ได้กำหนดค่าโดยอัตโนมัติผ่าน opencode คุณสามารถกำหนดค่าด้วยตนเองได้ตลอดเวลา

นี่คือ Helicone’s Model Directory คุณจะต้องใช้สิ่งนี้เพื่อรับ ID ของโมเดลที่คุณต้องการเพิ่ม

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
      },
      "models": {
        "gpt-4o": {
          // Model ID (from Helicone's model directory page)
          "name": "GPT-4o", // Your own custom name for the model
        },
        "claude-sonnet-4-20250514": {
          "name": "Claude Sonnet 4",
        },
      },
    },
  },
}

ส่วนหัวที่กำหนดเอง

Helicone รองรับส่วนหัวแบบกำหนดเองสำหรับฟีเจอร์ต่างๆ เช่น การแคช การติดตามผู้ใช้ และการจัดการเซสชัน เพิ่มลงในการกำหนดค่าผู้ให้บริการของคุณโดยใช้ options.headers:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
        "headers": {
          "Helicone-Cache-Enabled": "true",
          "Helicone-User-Id": "opencode",
        },
      },
    },
  },
}

การติดตามเซสชัน

คุณลักษณะ เซสชัน ของ Helicone ช่วยให้คุณสามารถจัดกลุ่มคำขอ LLM ที่เกี่ยวข้องเข้าด้วยกันได้ ใช้ปลั๊กอิน opencode-helicone-session เพื่อบันทึกการสนทนา OpenCode แต่ละรายการเป็นเซสชันใน Helicone โดยอัตโนมัติ

npm install -g opencode-helicone-session

เพิ่มลงในการกำหนดค่าของคุณ

{
  "plugin": ["opencode-helicone-session"]
}

ปลั๊กอินจะแทรกส่วนหัว Helicone-Session-Id และ Helicone-Session-Name ลงในคำขอของคุณ ในหน้าเซสชันของ Helicone คุณจะเห็นการสนทนา OpenCode แต่ละรายการแยกเป็นเซสชันแยกกัน

ส่วนหัวของ Helicone ทั่วไป

ส่วนหัว	คำอธิบาย
`Helicone-Cache-Enabled`	เปิดใช้งานการแคชการตอบกลับ (`true`/`false`)
`Helicone-User-Id`	ติดตามตัวชี้วัดตามผู้ใช้
`Helicone-Property-[Name]`	เพิ่มคุณสมบัติที่กำหนดเอง (เช่น `Helicone-Property-Environment`)
`Helicone-Prompt-Id`	เชื่อมโยงคำขอกับเวอร์ชันพร้อมท์

ดู Helicone Header Directory สำหรับส่วนหัวที่มีอยู่ทั้งหมด

llama.cpp

คุณสามารถกำหนดค่า opencode เพื่อใช้โมเดลท้องถิ่นผ่านยูทิลิตี้ llama.cpp’s llama-server

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "llama-server (local)",
      "options": {
        "baseURL": "http://127.0.0.1:8080/v1"
      },
      "models": {
        "qwen3-coder:a3b": {
          "name": "Qwen3-Coder: a3b-30b (local)",
          "limit": {
            "context": 128000,
            "output": 65536
          }
        }
      }
    }
  }
}

ในตัวอย่างนี้:

llama.cpp คือ ID ผู้ให้บริการที่กำหนดเอง นี่อาจเป็นสตริงใดก็ได้ที่คุณต้องการ
npm ระบุแพ็คเกจที่จะใช้สำหรับผู้ให้บริการรายนี้ ในที่นี้ @ai-sdk/openai-compatible ใช้สำหรับ API ที่เข้ากันได้กับ OpenAI
name คือชื่อที่แสดงของผู้ให้บริการใน UI
options.baseURL เป็นจุดสิ้นสุดสำหรับเซิร์ฟเวอร์ภายในเครื่อง
models คือแมปของ ID โมเดลกับการกำหนดค่า ชื่อรุ่นจะปรากฏในรายการเลือกรุ่น

ไอโอ.NET

IO.NET มี 17 โมเดลที่ได้รับการปรับให้เหมาะกับการใช้งานที่หลากหลาย:

ไปที่ IO.NET console สร้างบัญชี และสร้างคีย์ API
รันคำสั่ง /connect และค้นหา IO.NET
```
/connect
```
ป้อนคีย์ IO.NET API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่น
```
/models
```

LM Studio

คุณสามารถกำหนดค่า opencode เพื่อใช้โมเดลท้องถิ่นผ่าน LM Studio

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1234/v1"
      },
      "models": {
        "google/gemma-3n-e4b": {
          "name": "Gemma 3n-e4b (local)"
        }
      }
    }
  }
}

ในตัวอย่างนี้:

lmstudio คือ ID ผู้ให้บริการที่กำหนดเอง นี่อาจเป็นสตริงใดก็ได้ที่คุณต้องการ
npm ระบุแพ็คเกจที่จะใช้สำหรับผู้ให้บริการรายนี้ ในที่นี้ @ai-sdk/openai-compatible ใช้สำหรับ API ที่เข้ากันได้กับ OpenAI
name คือชื่อที่แสดงของผู้ให้บริการใน UI
options.baseURL เป็นจุดสิ้นสุดสำหรับเซิร์ฟเวอร์ภายในเครื่อง
models คือแมปของ ID โมเดลกับการกำหนดค่า ชื่อรุ่นจะปรากฏในรายการเลือกรุ่น

Moonshot AI

วิธีใช้ Kimi K2 จาก Moonshot AI:

ไปที่ Moonshot AI console สร้างบัญชี แล้วคลิก สร้าง API คีย์
รันคำสั่ง /connect และค้นหา Moonshot AI
```
/connect
```
ป้อนคีย์ Moonshot API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือก Kimi K2
```
/models
```

MiniMax

ไปที่ MiniMax API Console สร้างบัญชี และสร้างคีย์ API
เรียกใช้คำสั่ง /connect และค้นหา MiniMax
```
/connect
```
ป้อนคีย์ MiniMax API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่นเช่น M2.1
```
/models
```

Nebius Token Factory

ไปที่ คอนโซล Nebius Token Factory สร้างบัญชี แล้วคลิก เพิ่มรหัส
รันคำสั่ง /connect และค้นหา Nebius Token Factory
```
/connect
```
ป้อนคีย์ Nebius Token Factory API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น Kimi K2 Instruct
```
/models
```

Ollama

คุณสามารถกำหนดค่า opencode เพื่อใช้โมเดลท้องถิ่นผ่าน Ollama

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "llama2": {
          "name": "Llama 2"
        }
      }
    }
  }
}

ในตัวอย่างนี้:

ollama คือ ID ผู้ให้บริการที่กำหนดเอง นี่อาจเป็นสตริงใดก็ได้ที่คุณต้องการ
npm ระบุแพ็คเกจที่จะใช้สำหรับผู้ให้บริการรายนี้ ในที่นี้ @ai-sdk/openai-compatible ใช้สำหรับ API ที่เข้ากันได้กับ OpenAI
name คือชื่อที่แสดงของผู้ให้บริการใน UI
options.baseURL เป็นจุดสิ้นสุดสำหรับเซิร์ฟเวอร์ภายในเครื่อง
models คือแมปของ ID โมเดลกับการกำหนดค่า ชื่อรุ่นจะปรากฏในรายการเลือกรุ่น

Ollama Cloud

วิธีใช้ Ollama Cloud กับ OpenCode:

ไปที่ https://ollama.com/ แล้วลงชื่อเข้าใช้หรือสร้างบัญชี
ไปที่ การตั้งค่า > คีย์ แล้วคลิก เพิ่ม API คีย์ เพื่อสร้างคีย์ API ใหม่
คัดลอกคีย์ API เพื่อใช้ใน OpenCode
เรียกใช้คำสั่ง /connect และค้นหา Ollama Cloud
```
/connect
```
ป้อนคีย์ Ollama Cloud API ของคุณ
```
┌ API key
│
│
└ enter
```
สำคัญ: ก่อนที่จะใช้โมเดลคลาวด์ใน OpenCode คุณต้องดึงข้อมูลโมเดลในเครื่อง:
Terminal window
```
ollama pull gpt-oss:20b-cloud
```
รันคำสั่ง /models เพื่อเลือกโมเดล Ollama Cloud ของคุณ
```
/models
```

OpenAI

เราขอแนะนำให้สมัคร ChatGPT Plus หรือ Pro

เมื่อคุณสมัครแล้ว ให้รันคำสั่ง /connect และเลือก OpenAI
```
/connect
```
ที่นี่คุณสามารถเลือกตัวเลือก ChatGPT Plus/Pro จากนั้นเบราว์เซอร์จะเปิดขึ้นมา และขอให้คุณตรวจสอบสิทธิ์
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
ตอนนี้โมเดล OpenAI ทั้งหมดควรจะพร้อมใช้งานเมื่อคุณใช้คำสั่ง /models
```
/models
```

ใช้API Key

หากคุณมีคีย์ API อยู่แล้ว คุณสามารถเลือก ป้อนคีย์ API ด้วยตนเอง และวางลงใน terminal ของคุณ

โอเพ่นโค้ดเซน

OpenCode Zen คือรายการโมเดลที่ได้รับการทดสอบและตรวจสอบแล้วโดยทีมงาน OpenCode เรียนรู้เพิ่มเติม

ลงชื่อเข้าใช้ OpenCode Zen และคลิก สร้าง API คีย์
เรียกใช้คำสั่ง /connect และค้นหา OpenCode Zen
```
/connect
```
ป้อนคีย์ OpenCode API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่นเช่น Qwen 3 Coder 480B
```
/models
```

เปิดเราเตอร์

ไปที่ แดชบอร์ด OpenRouter คลิก สร้าง API คีย์ และคัดลอกคีย์
เรียกใช้คำสั่ง /connect และค้นหา OpenRouter
```
/connect
```
ป้อนคีย์ API สำหรับผู้ให้บริการ
```
┌ API key
│
│
└ enter
```
OpenRouter หลายรุ่นถูกโหลดไว้ล่วงหน้าตามค่าเริ่มต้น ให้รันคำสั่ง /models เพื่อเลือกรุ่นที่คุณต้องการ
```
/models
```
คุณยังสามารถเพิ่มโมเดลเพิ่มเติมผ่านการกำหนดค่า opencode ของคุณ
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

คุณยังสามารถปรับแต่งได้ผ่านการกำหนดค่า opencode ของคุณ นี่คือตัวอย่างการระบุผู้ให้บริการ

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "moonshotai/kimi-k2": {
          "options": {
            "provider": {
              "order": ["baseten"],
              "allow_fallbacks": false
            }
          }
        }
      }
    }
  }
}

SAP เอไอคอร์

SAP AI Core ให้การเข้าถึงโมเดลมากกว่า 40 โมเดลจาก OpenAI, Anthropic, Google, Amazon, Meta, Mistral และ AI21 ผ่านแพลตฟอร์มแบบครบวงจร

ไปที่ห้องนักบิน SAP BTP นำทางไปยังอินสแตนซ์บริการ SAP AI Core ของคุณ และสร้างรหัสบริการ

รหัสบริการคือวัตถุ JSON ที่ประกอบด้วย clientid, clientsecret, url และ serviceurls.AI_API_URL คุณสามารถค้นหาอินสแตนซ์ AI Core ของคุณได้ภายใต้ บริการ > อินสแตนซ์และการสมัครสมาชิก ในห้องควบคุม BTP
รันคำสั่ง /connect และค้นหา SAP AI Core
```
/connect
```
ป้อนรหัสบริการของคุณ JSON
```
┌ Service key
│
│
└ enter
```
หรือตั้งค่าตัวแปรสภาพแวดล้อม AICORE_SERVICE_KEY:
Terminal window
```
AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' opencode
```
หรือเพิ่มลงในโปรไฟล์ทุบตีของคุณ:
~/.bash_profile
```
export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'
```
ตั้งค่า ID การนำไปใช้งานและกลุ่มทรัพยากรเพิ่มเติม:
Terminal window
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
การตั้งค่าเหล่านี้เป็นทางเลือกและควรกำหนดค่าตามการตั้งค่า SAP AI Core ของคุณ
รันคำสั่ง /models เพื่อเลือกจากรุ่นที่มีให้เลือกมากกว่า 40 รุ่น
```
/models
```

ตำแหน่งข้อมูล AI ของ OVHcloud

ไปที่ แผง OVHcloud ไปที่ส่วน Public Cloud AI & Machine Learning > AI Endpoints และในแท็บ API Keys คลิก สร้างคีย์ API ใหม่
รันคำสั่ง /connect และค้นหา OVHcloud AI Endpoints
```
/connect
```
ป้อนคีย์ OVHcloud AI Endpoints API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น gpt-oss-120b
```
/models
```

สเกลเวย์

วิธีใช้ Scaleway Generative API กับ Opencode:

ไปที่ การตั้งค่า Scaleway Console IAM เพื่อสร้างคีย์ API ใหม่
รันคำสั่ง /connect และค้นหา Scaleway
```
/connect
```
ป้อนคีย์ Scaleway API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดล เช่น devstral-2-123b-instruct-2512 หรือ gpt-oss-120b
```
/models
```

ร่วมกันเอไอ

ไปที่ Together AI console สร้างบัญชี แล้วคลิก เพิ่มรหัส
เรียกใช้คำสั่ง /connect และค้นหา Together AI
```
/connect
```
ป้อนคีย์ Together AI API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น Kimi K2 Instruct
```
/models
```

เวนิส เอไอ

ไปที่ คอนโซล AI ของเวนิส สร้างบัญชี และสร้างคีย์ API
รันคำสั่ง /connect และค้นหา Venice AI
```
/connect
```
ป้อนคีย์ Venice AI API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น Llama 3.3 70B
```
/models
```

เกตเวย์ AI ของ Vercel

Vercel AI Gateway ช่วยให้คุณเข้าถึงโมเดลจาก OpenAI, Anthropic, Google, xAI และอื่นๆ อีกมากมายผ่านจุดสิ้นสุดแบบรวม โมเดลมีจำหน่ายในราคาปลีกโดยไม่มีส่วนเพิ่ม

ไปที่ แดชบอร์ด Vercel ไปที่แท็บ เกตเวย์ AI และคลิก API คีย์ เพื่อสร้างคีย์ API ใหม่
รันคำสั่ง /connect และค้นหา Vercel AI Gateway
```
/connect
```
ป้อนคีย์ Vercel AI Gateway API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่น
```
/models
```

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

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "vercel": {
      "models": {
        "anthropic/claude-sonnet-4": {
          "options": {
            "order": ["anthropic", "vertex"]
          }
        }
      }
    }
  }
}

ตัวเลือกการกำหนดเส้นทางที่มีประโยชน์:

ตัวเลือก	คำอธิบาย
`order`	ลำดับผู้ให้บริการที่จะลอง
`only`	จำกัดเฉพาะผู้ให้บริการบางราย
`zeroDataRetention`	ใช้ผู้ให้บริการที่ไม่มีนโยบายการเก็บรักษาข้อมูลเท่านั้น

xAI

ไปที่ xAI console สร้างบัญชี และสร้างคีย์ API
รันคำสั่ง /connect และค้นหา xAI
```
/connect
```
ป้อนคีย์ xAI API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น Grok Beta
```
/models
```

ซี.เอ.ไอ

ไปที่ Z.AI API console สร้างบัญชี และคลิก สร้างคีย์ API ใหม่
รันคำสั่ง /connect และค้นหา Z.AI
```
/connect
```
หากคุณสมัครสมาชิก GLM Coding Plan ให้เลือก Z.AI Coding Plan
ป้อนคีย์ Z.AI API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น GLM-4.7
```
/models
```

ZenMux

ไปที่ แดชบอร์ด ZenMux คลิก สร้าง API คีย์ และคัดลอกคีย์
รันคำสั่ง /connect และค้นหา ZenMux
```
/connect
```
ป้อนคีย์ API สำหรับผู้ให้บริการ
```
┌ API key
│
│
└ enter
```
ZenMux หลายรุ่นถูกโหลดไว้ล่วงหน้าตามค่าเริ่มต้น รันคำสั่ง /models เพื่อเลือกรุ่นที่คุณต้องการ
```
/models
```
คุณยังสามารถเพิ่มโมเดลเพิ่มเติมผ่านการกำหนดค่า opencode ของคุณ
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

ผู้ให้บริการที่กำหนดเอง

หากต้องการเพิ่มผู้ให้บริการ รองรับ OpenAI ที่ไม่อยู่ในคำสั่ง /connect:

เรียกใช้คำสั่ง /connect และเลื่อนลงไปที่ อื่นๆ
Terminal window
```
$ /connect

┌  Add credential
│
◆  Select provider
│  ...
│  ● Other
└
```
ป้อนรหัสเฉพาะสำหรับผู้ให้บริการ
Terminal window
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
เลือก ID ที่น่าจดจำ คุณจะใช้รหัสนี้ในไฟล์กำหนดค่าของคุณ

ป้อนรหัส API ของคุณสำหรับผู้ให้บริการ

$ /connect

┌  Add credential
│
▲  This only stores a credential for myprovider - you will need to configure it in opencode.json, check the docs for examples.
│
◇  Enter your API key
│  sk-...
└

สร้างหรืออัปเดตไฟล์ opencode.json ในไดเรกทอรีโครงการของคุณ:
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}
```
นี่คือตัวเลือกการกำหนดค่า:
- npm: แพ็คเกจ AI SDK ที่จะใช้ @ai-sdk/openai-compatible สำหรับผู้ให้บริการที่เข้ากันได้กับ OpenAI
- ชื่อ: ชื่อที่แสดงใน UI
- รุ่น: รุ่นที่มีจำหน่าย
- options.baseURL: API ปลายทาง URL
- options.apiKey: ตั้งค่าคีย์ API หรือไม่ก็ได้ หากไม่ได้ใช้การตรวจสอบสิทธิ์
- options.headers: ตั้งค่าส่วนหัวที่กำหนดเองหรือไม่ก็ได้
ข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกขั้นสูงในตัวอย่างด้านล่าง
รันคำสั่ง /models จากนั้นผู้ให้บริการและโมเดลที่คุณกำหนดเองจะปรากฏในรายการตัวเลือก

ตัวอย่าง

นี่คือตัวอย่างการตั้งค่าตัวเลือก apiKey, headers และโมเดล limit

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1",
        "apiKey": "{env:ANTHROPIC_API_KEY}",
        "headers": {
          "Authorization": "Bearer custom-token"
        }
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name",
          "limit": {
            "context": 200000,
            "output": 65536
          }
        }
      }
    }
  }
}

รายละเอียดการกำหนดค่า:

apiKey: ตั้งค่าโดยใช้ไวยากรณ์ของตัวแปร env เรียนรู้เพิ่มเติม
ส่วนหัว: ส่วนหัวที่กำหนดเองส่งไปพร้อมกับคำขอแต่ละรายการ
limit.context: Input Tokens สูงสุดที่โมเดลยอมรับ
limit.output: Output Tokens สูงสุดที่โมเดลสามารถสร้างได้

ช่อง limit ช่วยให้ OpenCode เข้าใจบริบทที่คุณเหลืออยู่ ผู้ให้บริการมาตรฐานจะดึงข้อมูลเหล่านี้จาก models.dev โดยอัตโนมัติ

การแก้ไขปัญหา

หากคุณประสบปัญหาในการกำหนดค่าผู้ให้บริการ ให้ตรวจสอบสิ่งต่อไปนี้:

ตรวจสอบการตั้งค่าการรับรองความถูกต้อง: เรียกใช้ opencode auth list เพื่อดูว่ามีข้อมูลรับรองหรือไม่ สำหรับผู้ให้บริการจะถูกเพิ่มในการกำหนดค่าของคุณ

สิ่งนี้ใช้ไม่ได้กับผู้ให้บริการอย่าง Amazon Bedrock ที่ต้องอาศัยตัวแปรสภาพแวดล้อมสำหรับการตรวจสอบสิทธิ์
สำหรับผู้ให้บริการแบบกำหนดเอง ให้ตรวจสอบการกำหนดค่า opencode และ:
- ตรวจสอบให้แน่ใจว่า ID ผู้ให้บริการที่ใช้ในคำสั่ง /connect ตรงกับ ID ในการกำหนดค่า opencode ของคุณ
- มีการใช้แพ็คเกจ npm ที่ถูกต้องสำหรับผู้ให้บริการ ตัวอย่างเช่น ใช้ @ai-sdk/cerebras สำหรับ Cerebras และสำหรับผู้ให้บริการรายอื่นที่เข้ากันได้กับ OpenAI ให้ใช้ @ai-sdk/openai-compatible
- ตรวจสอบว่ามีการใช้จุดสิ้นสุด API ที่ถูกต้องในช่อง options.baseURL