opencode/packages/web/src/content/docs/th/providers.mdx at b7b8b06011ff58f7d52dc0f73df67b459d9f5dce · anomalyco/opencode

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

import config from "../../../../config.mjs" export const console = config.console

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

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

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

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

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

การกำหนดค่า

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

Base URL (URL พื้นฐาน)

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

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

OpenCode Zen

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

:::tip หากคุณยังใหม่ เราขอแนะนำให้เริ่มต้นด้วย OpenCode Zen :::

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

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

OpenCode Go

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

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

ไดเรกทอรี

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

:::note ไม่เห็นผู้ให้บริการที่นี่ใช่ไหม ส่งพีอาร์. :::

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 และขอ เข้าถึงโมเดลที่คุณต้องการ

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

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

ตั้งค่าหนึ่งในตัวแปรสภาพแวดล้อมเหล่านี้ขณะเรียกใช้ opencode:
```
# 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
```
หรือเพิ่มลงในโปรไฟล์ทุบตีของคุณ:
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
ไฟล์การกำหนดค่า (แนะนำ)

สำหรับการกำหนดค่าเฉพาะโครงการหรือแบบถาวร ให้ใช้ 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 ทั่วไป)
:::tip ตัวเลือกไฟล์การกำหนดค่ามีความสำคัญเหนือกว่าตัวแปรสภาพแวดล้อม :::

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

หากคุณใช้จุดสิ้นสุด VPC สำหรับ Bedrock:
```
{
  "$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"
      }
    }
  }
}
```
:::note ตัวเลือก 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), ข้อมูลเมตาของอินสแตนซ์
:::note เมื่อตั้งค่าBearer Token (ผ่าน /connect หรือ AWS_BEARER_TOKEN_BEDROCK) โทเค็นนั้นจะมีความสำคัญเหนือกว่าวิธีการข้อมูลประจำตัว AWS ทั้งหมด รวมถึงโปรไฟล์ที่กำหนดค่าไว้ :::
รันคำสั่ง /models เพื่อเลือกรุ่นที่ต้องการ
```
/models
```

:::note สำหรับโปรไฟล์การอนุมานแบบกำหนดเอง ให้ใช้ชื่อรุ่นและผู้ให้บริการในคีย์และตั้งค่าคุณสมบัติ 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
```

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

การใช้ API Key

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

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

Atomic Chat

คุณสามารถกำหนดค่า opencode ให้ใช้โมเดลท้องถิ่นผ่าน Atomic Chat ซึ่งเป็นแอปพลิเคชันเดสก์ท็อปที่เรียกใช้ LLM ในเครื่องภายใต้เซิร์ฟเวอร์ API ที่เข้ากันได้กับ OpenAI (ปลายทางเริ่มต้น http://127.0.0.1:1337/v1)

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "atomic-chat": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Atomic Chat (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1337/v1"
      },
      "models": {
        "<your-model-id>": {
          "name": "<your-model-name>"
        }
      }
    }
  }
}

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

atomic-chat คือรหัสผู้ให้บริการที่กำหนดเอง สามารถเป็นสตริงใดก็ได้ที่คุณต้องการ
npm ระบุแพ็กเกจที่จะใช้สำหรับผู้ให้บริการนี้ ที่นี่ใช้ @ai-sdk/openai-compatible สำหรับ API ใดๆ ที่เข้ากันได้กับ OpenAI
name คือชื่อแสดงของผู้ให้บริการในอินเทอร์เฟซ
options.baseURL คือปลายทางของเซิร์ฟเวอร์ท้องถิ่น เปลี่ยนโฮสต์และพอร์ตให้ตรงกับการตั้งค่า Atomic Chat ของคุณ
models คือแผนที่ระหว่างรหัสโมเดลกับชื่อแสดง แต่ละรหัสต้องตรงกับ id ที่ส่งคืนโดย GET /v1/models — รัน curl http://127.0.0.1:1337/v1/models เพื่อแสดงรายการรหัสที่โหลดอยู่ใน Atomic Chat

:::tip หากการเรียกเครื่องมือทำงานได้ไม่ดี ให้เลือกโมเดลที่โหลดแล้วซึ่งรองรับ tool calling ได้ดี (ตัวอย่างเช่น รุ่น Qwen-Coder หรือ DeepSeek-Coder) :::

Azure OpenAI

:::note หากคุณพบข้อผิดพลาด "ฉันขอโทษ แต่ฉันไม่สามารถช่วยเหลือคำขอนั้นได้" ให้ลองเปลี่ยนตัวกรองเนื้อหาจาก DefaultV2 เป็น Default ในทรัพยากร Azure ของคุณ :::

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

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

Azure Cognitive Services

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

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

Baseten

ไปที่ 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

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

ไปที่ แดชบอร์ด Cloudflare ไปที่ AI > AI Gateway และสร้างเกตเวย์ใหม่
ตั้งค่ารหัสบัญชีและรหัสเกตเวย์ของคุณเป็นตัวแปรสภาพแวดล้อม
```
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
```
หรือตั้งเป็นตัวแปรสภาพแวดล้อม
```
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

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

DeepSeek

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

Deep Infra

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

FrogBot

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

Fireworks AI

ไปที่ คอนโซล Fireworks AI สร้างบัญชี แล้วคลิก Create API Key
รันคำสั่ง /connect และค้นหา Fireworks AI
```
/connect
```
ป้อนคีย์ Fireworks 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 และเบราว์เซอร์ของคุณจะเปิดขึ้นเพื่อรับสิทธิ์

การใช้ 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 - มีความสามารถมากที่สุดสำหรับการวิเคราะห์ที่ซับซ้อน

:::note คุณยังสามารถระบุตัวแปรสภาพแวดล้อม 'GITLAB_TOKEN' ได้หากคุณไม่ต้องการ เพื่อจัดเก็บโทเค็นในที่เก็บข้อมูลการรับรองความถูกต้องของ opencode :::

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

:::note[บันทึกการปฏิบัติตาม] 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-...

:::note ผู้ดูแลระบบ GitLab ของคุณต้องเปิดใช้งานสิ่งต่อไปนี้:

Duo Agent Platform สำหรับผู้ใช้ กลุ่ม หรืออินสแตนซ์
แฟล็กคุณลักษณะ (ผ่านคอนโซล Rails):
- agent_platform_claude_code
- third_party_agents_enabled :::

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"
      }
    }
  }
}

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

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

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

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

GitHub Copilot

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

:::note บางรุ่นอาจต้องมี Pro+ subscription เพื่อใช้งาน

บางรุ่นจำเป็นต้องเปิดใช้งานด้วยตนเองใน การตั้งค่า GitHub Copilot :::

รันคำสั่ง /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

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

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

:::note คุณต้องมีโปรเจ็กต์ 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
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
หรือเพิ่มลงในโปรไฟล์ทุบตีของคุณ
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

:::tip ภูมิภาค global ปรับปรุงความพร้อมใช้งานและลดข้อผิดพลาดโดยไม่มีค่าใช้จ่ายเพิ่มเติม ใช้ตำแหน่งข้อมูลระดับภูมิภาค (เช่น us-central1) สำหรับข้อกำหนดด้านถิ่นที่อยู่ของข้อมูล เรียนรู้เพิ่มเติม :::

รันคำสั่ง /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

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 โมเดลกับการกำหนดค่า ชื่อรุ่นจะปรากฏในรายการเลือกรุ่น

IO.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 สร้างบัญชี แล้วคลิก Create API Key
รันคำสั่ง /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 สร้างบัญชี แล้วคลิก Add key
รันคำสั่ง /connect และค้นหา Nebius Token Factory
```
/connect
```
ป้อนคีย์ Nebius Token Factory API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกโมเดลเช่น Kimi K2 Instruct
```
/models
```

Ollama

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

:::tip 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 โมเดลกับการกำหนดค่า ชื่อรุ่นจะปรากฏในรายการเลือกรุ่น

:::tip หากการเรียกใช้เครื่องมือไม่ทำงาน ให้ลองเพิ่ม num_ctx ใน Ollama เริ่มต้นประมาณ 16,000 - 32,000 :::

Ollama Cloud

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

ไปที่ https://ollama.com/ แล้วลงชื่อเข้าใช้หรือสร้างบัญชี
ไปที่ Settings > Keys แล้วคลิก Add API Key เพื่อสร้างคีย์ API ใหม่
คัดลอกคีย์ API เพื่อใช้ใน OpenCode
เรียกใช้คำสั่ง /connect และค้นหา Ollama Cloud
```
/connect
```
ป้อนคีย์ Ollama Cloud API ของคุณ
```
┌ API key
│
│
└ enter
```
สำคัญ: ก่อนที่จะใช้โมเดลคลาวด์ใน OpenCode คุณต้องดึงข้อมูลโมเดลในเครื่อง:
```
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 อยู่แล้ว คุณสามารถเลือก Manually enter API Key และวางลงใน terminal ของคุณ

OpenCode Zen

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

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

OpenRouter

ไปที่ OpenRouter dashboard คลิก Create API Key และคัดลอกคีย์
เรียกใช้คำสั่ง /connect และค้นหา OpenRouter
```
/connect
```
ป้อนคีย์ API สำหรับผู้ให้บริการ
```
┌ API key
│
│
└ enter
```
โมเดล OpenRouter จำนวนมากถูกโหลดไว้ล่วงหน้าตามค่าเริ่มต้น รันคำสั่ง /models เพื่อเลือกโมเดลที่คุณต้องการ
```
/models
```
คุณยังสามารถเพิ่มโมเดลเพิ่มเติมผ่านการกำหนดค่า opencode ของคุณได้
```
{
  "$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 AI Core

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

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

:::tip คีย์บริการคือวัตถุ JSON ที่มี clientid, clientsecret, url และ serviceurls.AI_API_URL คุณสามารถค้นหาอินสแตนซ์ AI Core ของคุณได้ภายใต้ Services > Instances and Subscriptions ใน BTP Cockpit :::
เรียกใช้คำสั่ง /connect และค้นหา SAP AI Core
```
/connect
```

ป้อน JSON คีย์บริการของคุณ

┌ Service key
│
│
└ enter

หรือตั้งค่าตัวแปรสภาพแวดล้อม AICORE_SERVICE_KEY:

AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' opencode

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

export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'

เลือกตั้งค่ารหัสการปรับใช้และกลุ่มทรัพยากร:
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
:::note การตั้งค่าเหล่านี้เป็นทางเลือกและควรกำหนดค่าตามการตั้งค่า SAP AI Core ของคุณ :::
รันคำสั่ง /models เพื่อเลือกจาก 40+ รุ่นที่มีอยู่
```
/models
```

STACKIT

STACKIT AI Model Serving มอบสภาพแวดล้อมการโฮสต์ที่มีการจัดการเต็มรูปแบบสำหรับโมเดล AI โดยเน้นที่ LLM เช่น Llama, Mistral และ Qwen โดยมีอธิปไตยของข้อมูลสูงสุดบนโครงสร้างพื้นฐานยุโรป

ไปที่ STACKIT Portal ไปที่ AI Model Serving และสร้างโทเค็นการตรวจสอบสิทธิ์สำหรับโครงการของคุณ

:::tip คุณต้องมีบัญชีลูกค้า STACKIT บัญชีผู้ใช้ และโครงการก่อนสร้างโทเค็นการตรวจสอบสิทธิ์ :::
เรียกใช้คำสั่ง /connect และค้นหา STACKIT
```
/connect
```
ป้อนโทเค็นการตรวจสอบสิทธิ์ STACKIT AI Model Serving ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกจากโมเดลที่มีอยู่ เช่น Qwen3-VL 235B หรือ Llama 3.3 70B
```
/models
```

OVHcloud AI Endpoints

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

Scaleway

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

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

Together AI

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

Venice AI

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

Vercel AI Gateway

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

ไปที่ Vercel dashboard ไปที่แท็บ AI Gateway และคลิก API keys เพื่อสร้างคีย์ 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

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

ZenMux

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

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

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

:::tip คุณสามารถใช้ผู้ให้บริการที่เข้ากันได้กับ OpenAI กับ opencode ได้ ผู้ให้บริการ AI สมัยใหม่ส่วนใหญ่เสนอ API ที่เข้ากันได้กับ OpenAI :::

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

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

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
:::note เลือก ID ที่น่าจดจำ คุณจะใช้ 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 ของคุณในไดเร็กทอรีโครงการของคุณ:
```
{
  "$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
- name: ชื่อที่แสดงใน UI
- models: โมเดลที่มีจำหน่าย
- options.baseURL: URL จุดสิ้นสุด API
- 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 เรียนรู้เพิ่มเติม
headers: ส่วนหัวที่กำหนดเองที่ส่งไปกับแต่ละคำขอ
limit.context: โทเค็นอินพุตสูงสุดที่โมเดลยอมรับ
limit.output: โทเค็นสูงสุดที่โมเดลสามารถสร้างได้

ฟิลด์ 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
ป้อนคีย์ OpenCode API ของคุณ
```
┌ API key
│
│
└ enter
```
รันคำสั่ง /models เพื่อเลือกรุ่นเช่น Qwen 3 Coder 480B
```
/models
```

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

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

{
  "$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 ของคุณ และสร้างรหัสบริการ

:::tip รหัสบริการคือวัตถุ JSON ที่ประกอบด้วย clientid, clientsecret, url และ serviceurls.AI_API_URL คุณสามารถค้นหาอินสแตนซ์ AI Core ของคุณได้ภายใต้ บริการ > อินสแตนซ์และการสมัครสมาชิก ในห้องควบคุม BTP :::
รันคำสั่ง /connect และค้นหา SAP AI Core
```
/connect
```

ป้อนรหัสบริการของคุณ JSON

┌ Service key
│
│
└ enter

หรือตั้งค่าตัวแปรสภาพแวดล้อม AICORE_SERVICE_KEY:

AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' opencode

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

export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'

ตั้งค่า ID การนำไปใช้งานและกลุ่มทรัพยากรเพิ่มเติม:
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
:::note การตั้งค่าเหล่านี้เป็นทางเลือกและควรกำหนดค่าตามการตั้งค่า 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 ของคุณ
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

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

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

:::tip คุณสามารถใช้ผู้ให้บริการที่เข้ากันได้กับ OpenAI ด้วย opencode ผู้ให้บริการ AI สมัยใหม่ส่วนใหญ่เสนอ API ที่เข้ากันได้กับ OpenAI :::

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

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

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
:::note เลือก 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 ในไดเรกทอรีโครงการของคุณ:
```
{
  "$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

FilesExpand file tree

providers.mdx

Latest commit

History

providers.mdx

File metadata and controls

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

การกำหนดค่า

Base URL (URL พื้นฐาน)

OpenCode Zen

OpenCode Go

ไดเรกทอรี

302.AI

Amazon Bedrock

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

ไฟล์การกำหนดค่า (แนะนำ)

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

วิธีการรับรองความถูกต้อง

ลำดับความสำคัญของการรับรองความถูกต้อง

Anthropic

การใช้ API Key

Atomic Chat

Azure OpenAI

Azure Cognitive Services

Baseten

Cerebras

Cloudflare AI Gateway

Cortecs

DeepSeek

Deep Infra

FrogBot

Fireworks AI

GitLab Duo

การใช้ OAuth (แนะนำ)

การใช้ Personal Access Token

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

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

การกำหนดค่า

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

GitHub Copilot

Google Vertex AI

Groq

Hugging Face

Helicone

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

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

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

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

llama.cpp

IO.NET

LM Studio

Moonshot AI

MiniMax

Nebius Token Factory

Ollama

Ollama Cloud

OpenAI

การใช้ API Key

OpenCode Zen

OpenRouter

SAP AI Core

STACKIT

OVHcloud AI Endpoints

Scaleway

Together AI

Venice AI

Vercel AI Gateway

xAI

Z.AI

ZenMux

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

ตัวอย่าง

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

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

SAP เอไอคอร์

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

สเกลเวย์

ร่วมกันเอไอ

เวนิส เอไอ

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