हिन्दी
दस्तावेज़
प्रदाता

प्रदाता

OpenCode में किसी भी LLM प्रदाता का उपयोग करना।

OpenCode 75+ LLM प्रदाताओं को सपोर्ट करने के लिए AI SDK (opens in a new tab) और Models.dev (opens in a new tab) का उपयोग करता है और यह स्थानीय मॉडल चलाने को सपोर्ट करता है।

एक प्रदाता जोड़ने के लिए आपको यह करना होगा:

  1. /connect कमांड का उपयोग करके प्रदाता के लिए API कुंजियाँ जोड़ें।
  2. अपनी OpenCode कॉन्फ़िग में प्रदाता को कॉन्फ़िगर करें।

क्रेडेंशियल

जब आप /connect कमांड के साथ किसी प्रदाता की API कुंजियाँ जोड़ते हैं, तो वे ~/.local/share/opencode/auth.json में संग्रहीत होती हैं।

कॉन्फ़िगरेशन

आप अपनी OpenCode कॉन्फ़िग में provider अनुभाग के माध्यम से प्रदाताओं को कस्टमाइज़ कर सकते हैं।

बेस URL

आप baseURL विकल्प सेट करके किसी भी प्रदाता के लिए base URL को कस्टमाइज़ कर सकते हैं। यह प्रॉक्सी सेवाओं या कस्टम एंडपॉइंट का उपयोग करते समय उपयोगी है।

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

मॉडल छिपाना

आप blacklist विकल्प का उपयोग करके किसी प्रदाता के लिए /models पिकर से विशिष्ट मॉडलों को छिपा सकते हैं। यह तब उपयोगी है जब कोई प्रदाता ऐसे मॉडल एक्सपोज़ करता है जिन्हें आप उपयोग या चयन नहीं करना चाहते।

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "blacklist": ["claude-opus-4-20250514"]
    }
  }
}

इसका उलटा whitelist विकल्प सूचीबद्ध मॉडलों को छोड़कर बाकी सभी को छिपा देता है।

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "anthropic": {
      "whitelist": ["claude-sonnet-4-20250514"]
    }
  }
}

दोनों विकल्प मॉडल ID की एक array लेते हैं — वही ID जो /models पिकर में दिखाई जाती हैं।

  • blacklist सूचीबद्ध मॉडलों को पिकर से हटा देता है।
  • whitelist केवल सूचीबद्ध मॉडलों को रखता है और बाकी को छिपा देता है।
  • आप इन्हें जोड़ भी सकते हैं: whitelist सेट को संकुचित करता है, फिर blacklist उसमें से एंट्री हटा देता है।

OpenCode Zen

OpenCode Zen OpenCode टीम द्वारा प्रदान किए गए मॉडलों की एक सूची है जिन्हें OpenCode के साथ अच्छा काम करने के लिए परीक्षित और सत्यापित किया गया है। और जानें।

Tip: यदि आप नए हैं, तो हम OpenCode Zen से शुरू करने की अनुशंसा करते हैं।

  1. TUI में /connect कमांड चलाएँ, OpenCode Zen का चयन करें, और opencode.ai/auth (opens in a new tab) पर जाएँ।

    /connect

  2. साइन इन करें, अपना बिलिंग विवरण जोड़ें, और अपनी API कुंजी कॉपी करें।

  3. अपनी API कुंजी पेस्ट करें।

    ┌ API key
│
│
└ enter

  4. हमारे द्वारा अनुशंसित मॉडलों की सूची देखने के लिए TUI में /models चलाएँ।

    /models

यह OpenCode में किसी भी अन्य प्रदाता की तरह काम करता है और उपयोग करना पूरी तरह से वैकल्पिक है।

प्रदाता सूची

आइए कुछ प्रदाताओं को विस्तार से देखें। यदि आप सूची में कोई प्रदाता जोड़ना चाहते हैं, तो बेझिझक एक PR खोलें।

Note: यहाँ कोई प्रदाता नहीं दिख रहा? एक PR सबमिट करें।

302.AI

  1. 302.AI console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और 302.AI खोजें।

    /connect

  3. अपनी 302.AI API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

Amazon Bedrock

OpenCode के साथ Amazon Bedrock का उपयोग करने के लिए:

  1. Amazon Bedrock console में Model catalog पर जाएँ और उन मॉडलों तक पहुँच का अनुरोध करें जो आप चाहते हैं।

    Tip: आपके पास Amazon Bedrock में अपने इच्छित मॉडल तक पहुँच होनी चाहिए।

  2. निम्नलिखित विधियों में से किसी एक का उपयोग करके प्रमाणीकरण कॉन्फ़िगर करें:

    Environment Variables (त्वरित प्रारंभ)

    opencode चलाते समय इनमें से कोई एक environment variable सेट करें:

    # 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 में जोड़ें:

    ~/.bash_profile
    export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1

    Configuration File (अनुशंसित)

    प्रोजेक्ट-विशिष्ट या स्थायी कॉन्फ़िगरेशन के लिए, opencode.json का उपयोग करें:

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "my-aws-profile"
      }
    }
  }
}

    उपलब्ध विकल्प:

    • region - AWS region (जैसे, us-east-1 , eu-west-1 )

    • profile - ~/.aws/credentials से AWS named profile

    • endpoint - VPC एंडपॉइंट के लिए कस्टम एंडपॉइंट URL (सामान्य baseURL विकल्प के लिए उपनाम)

    Tip: कॉन्फ़िगरेशन फ़ाइल विकल्प environment variables पर प्राथमिकता रखते हैं।

    उन्नत: VPC Endpoints

    यदि आप Bedrock के लिए VPC एंडपॉइंट का उपयोग कर रहे हैं:

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

    Note: endpoint विकल्प AWS-विशिष्ट शब्दावली का उपयोग करते हुए सामान्य baseURL विकल्प के लिए एक उपनाम है। यदि endpoint और baseURL दोनों निर्दिष्ट हैं, तो endpoint को प्राथमिकता मिलती है।

    प्रमाणीकरण विधियाँ

    • AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY : AWS Console में एक IAM उपयोगकर्ता बनाएँ और access keys उत्पन्न करें
    • AWS_PROFILE : ~/.aws/credentials से named profiles का उपयोग करें। पहले aws configure --profile my-profile या aws sso login के साथ कॉन्फ़िगर करें
    • AWS_BEARER_TOKEN_BEDROCK : Amazon Bedrock console से दीर्घकालिक API कुंजियाँ उत्पन्न करें
    • AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN : EKS IRSA (Service Accounts के लिए IAM Roles) या OIDC federation वाले अन्य Kubernetes वातावरण के लिए। ये environment variables service account annotations का उपयोग करते समय Kubernetes द्वारा स्वचालित रूप से इंजेक्ट किए जाते हैं।

    प्रमाणीकरण प्राथमिकता

    Amazon Bedrock निम्नलिखित प्रमाणीकरण प्राथमिकता का उपयोग करता है:

    1. Bearer Token - AWS_BEARER_TOKEN_BEDROCK environment variable या /connect कमांड से टोकन

    2. AWS Credential Chain - Profile, access keys, shared credentials, IAM roles, Web Identity Tokens (EKS IRSA), instance metadata

    Note: जब एक bearer token सेट होता है (/connect या AWS_BEARER_TOKEN_BEDROCK के माध्यम से), तो यह कॉन्फ़िगर किए गए profiles सहित सभी AWS credential विधियों पर प्राथमिकता रखता है।

  3. अपना इच्छित मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

Note: कस्टम inference profiles के लिए, कुंजी में मॉडल और प्रदाता नाम का उपयोग करें और id गुण को arn पर सेट करें। यह सही caching सुनिश्चित करता है।

opencode.json
{
  "$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

  1. एक बार जब आप साइन अप कर लेते हैं, तो /connect कमांड चलाएँ और Anthropic का चयन करें।

    /connect

  2. यहाँ आप Claude Pro/Max विकल्प चुन सकते हैं और यह आपका ब्राउज़र खोलेगा और आपसे प्रमाणित करने के लिए कहेगा।

    ┌ Select auth method
│
│ Manually enter API Key
└

  3. अब /models कमांड का उपयोग करते समय सभी Anthropic मॉडल उपलब्ध होने चाहिए।

    /models

ऐसे प्लगइन हैं जो आपको OpenCode के साथ अपने Claude Pro/Max मॉडलों का उपयोग करने की अनुमति देते हैं। Anthropic स्पष्ट रूप से इसे प्रतिबंधित करता है।

OpenCode के पिछले संस्करण इन प्लगइनों के साथ बंडल किए गए थे लेकिन 1.3.0 के बाद से अब ऐसा नहीं है।

अन्य कंपनियाँ डेवलपर टूलिंग के साथ चयन की स्वतंत्रता का समर्थन करती हैं - आप OpenCode में निम्नलिखित सदस्यताओं का उपयोग शून्य सेटअप के साथ कर सकते हैं:

  • ChatGPT Plus
  • Github Copilot
  • Gitlab Duo

Atomic Chat

आप opencode को Atomic Chat (opens in a new tab) के माध्यम से स्थानीय मॉडलों का उपयोग करने के लिए कॉन्फ़िगर कर सकते हैं, जो एक डेस्कटॉप एप्लिकेशन है जो एक OpenAI-संगत API सर्वर (डिफ़ॉल्ट एंडपॉइंट http://127.0.0.1:1337/v1) के पीछे स्थानीय LLM चलाता है।

opencode.json
{
  "$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 कस्टम प्रदाता ID है। यह कोई भी स्ट्रिंग हो सकती है जो आप चाहें।
  • npm इस प्रदाता के लिए उपयोग किए जाने वाले पैकेज को निर्दिष्ट करता है। यहाँ, किसी भी OpenAI-संगत API के लिए @ai-sdk/openai-compatible का उपयोग किया जाता है।
  • name UI में प्रदाता के लिए प्रदर्शन नाम है।
  • options.baseURL स्थानीय सर्वर के लिए एंडपॉइंट है। अपने Atomic Chat सेटअप से मेल खाने के लिए host और port बदलें।
  • models मॉडल ID से उनके प्रदर्शन नामों का एक मैप है। प्रत्येक ID को GET /v1/models द्वारा लौटाए गए id से मेल खाना चाहिए — Atomic Chat में वर्तमान में लोड किए गए ids को सूचीबद्ध करने के लिए curl http://127.0.0.1:1337/v1/models चलाएँ।

Tip: यदि tool calls अच्छी तरह से काम नहीं कर रहे हैं, तो मजबूत tool-calling सपोर्ट वाला एक लोड किया गया मॉडल चुनें (उदाहरण के लिए, एक Qwen-Coder या DeepSeek-Coder वैरिएंट)।

Azure OpenAI

Note: यदि आपको "I'm sorry, but I cannot assist with that request" त्रुटियाँ मिलती हैं, तो अपने Azure resource में content filter को DefaultV2 से Default में बदलने का प्रयास करें।

  1. Azure portal (opens in a new tab) पर जाएँ और एक Azure OpenAI resource बनाएँ। आपको चाहिए होगा:

    • Resource name : यह आपके API एंडपॉइंट का हिस्सा बन जाता है ( https://RESOURCE_NAME.openai.azure.com/ )
    • API key : आपके resource से या तो KEY 1 या KEY 2

  2. Azure AI Foundry (opens in a new tab) पर जाएँ और एक मॉडल डिप्लॉय करें।

    Note: opencode के सही ढंग से काम करने के लिए deployment name मॉडल नाम से मेल खाना चाहिए।

  3. /connect कमांड चलाएँ और Azure खोजें।

    /connect

  4. अपनी API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  5. अपने resource name को एक environment variable के रूप में सेट करें:

    AZURE_RESOURCE_NAME=XXX opencode

    या इसे अपने bash profile में जोड़ें:

    ~/.bash_profile
    export AZURE_RESOURCE_NAME=XXX

  6. अपने डिप्लॉय किए गए मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Microsoft Entra ID (Azure CLI)

आप API key के बजाय Azure CLI session का उपयोग कर सकते हैं। Azure CLI इंस्टॉल करें (opens in a new tab), az login चलाएँ, फिर /connect में Azure और Microsoft Entra ID (Azure CLI) चुनें। पूछे जाने पर Azure Resource का नाम दर्ज करें। Resource किसी दूसरे tenant का हो तो az login --tenant TENANT_ID का उपयोग करें।

Azure portal (opens in a new tab) या Microsoft Foundry (opens in a new tab) में Azure OpenAI अथवा Foundry Resource खोलकर उसका नाम देखें। यह endpoint का पहला भाग भी है, जैसे https://my-models.openai.azure.com/ या https://my-models.services.ai.azure.com/ में my-models। यदि आपकी identity Resources सूचीबद्ध कर सकती है, तो नाम और Resource groups ऐसे भी देखें:

az cognitiveservices account list \
  --query "[].{name:name,resourceGroup:resourceGroup}" \
  --output table

OpenCode Azure management API से जानकारी नहीं माँगता और deployments अपने आप नहीं खोजता। ऐसा मॉडल चुनें जिसका catalog नाम आपके deployment से मेल खाता हो, या deployment का नाम स्पष्ट रूप से कॉन्फ़िगर करें:

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "azure": {
      "models": {
        "gpt-5-mini": {
          "id": "gpt-production"
        }
      }
    }
  }
}

Identity को आवश्यक inference role दें: Azure OpenAI models के लिए Cognitive Services OpenAI User, अन्य Foundry models के लिए Cognitive Services User। OpenCode Azure CLI से access tokens refresh करता है, 2.54.0 से पुराने versions में भी; CLI session समाप्त होने पर ही दोबारा sign in करना होगा।

Azure Cognitive Services

  1. Azure portal (opens in a new tab) पर जाएँ और एक Azure OpenAI resource बनाएँ। आपको चाहिए होगा:

    • Resource name : यह आपके API एंडपॉइंट का हिस्सा बन जाता है ( https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/ )
    • API key : आपके resource से या तो KEY 1 या KEY 2

  2. Azure AI Foundry (opens in a new tab) पर जाएँ और एक मॉडल डिप्लॉय करें।

    Note: opencode के सही ढंग से काम करने के लिए deployment name मॉडल नाम से मेल खाना चाहिए।

  3. /connect कमांड चलाएँ और Azure Cognitive Services खोजें।

    /connect

  4. अपनी API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  5. अपने resource name को एक environment variable के रूप में सेट करें:

    AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode

    या इसे अपने bash profile में जोड़ें:

    ~/.bash_profile
    export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX

  6. अपने डिप्लॉय किए गए मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Baseten

  1. Baseten (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और Baseten खोजें।

    /connect

  3. अपनी Baseten API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

Cerebras

  1. Cerebras console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और Cerebras खोजें।

    /connect

  3. अपनी Cerebras API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Qwen 3 Coder 480B जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Cloudflare AI Gateway

Cloudflare AI Gateway आपको एक एकीकृत एंडपॉइंट के माध्यम से OpenAI, Anthropic, Workers AI, और अधिक से मॉडलों तक पहुँचने देता है। Unified Billing (opens in a new tab) के साथ आपको प्रत्येक प्रदाता के लिए अलग API कुंजियों की आवश्यकता नहीं है।

  1. Cloudflare dashboard (opens in a new tab) पर जाएँ, AI > AI Gateway पर नेविगेट करें, और एक नया gateway बनाएँ। अपना Account ID और Gateway ID नोट करें।

  2. /connect कमांड चलाएँ और Cloudflare AI Gateway खोजें।

    /connect

  3. संकेत मिलने पर अपना Account ID दर्ज करें।

    ┌ Enter your Cloudflare Account ID
│
│
└ enter

  4. संकेत मिलने पर अपना Gateway ID दर्ज करें।

    ┌ Enter your Cloudflare AI Gateway ID
│
│
└ enter

  5. अपना Cloudflare API token दर्ज करें।

    ┌ Gateway API token
│
│
└ enter

  6. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

    आप अपनी opencode कॉन्फ़िग के माध्यम से भी मॉडल जोड़ सकते हैं।

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

    वैकल्पिक रूप से, आप /connect का उपयोग करने के बजाय environment variables सेट कर सकते हैं।

    ~/.bash_profile
    export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id
export CLOUDFLARE_API_TOKEN=your-api-token

Cloudflare Workers AI

Cloudflare Workers AI आपको Cloudflare के वैश्विक नेटवर्क पर सीधे REST API के माध्यम से AI मॉडल चलाने देता है, समर्थित मॉडलों के लिए किसी अलग प्रदाता खाते की आवश्यकता नहीं है।

  1. Cloudflare dashboard (opens in a new tab) पर जाएँ, Workers AI पर नेविगेट करें, और अपना Account ID प्राप्त करने और एक API token बनाने के लिए Use REST API चुनें।

  2. /connect कमांड चलाएँ और Cloudflare Workers AI खोजें।

    /connect

  3. संकेत मिलने पर अपना Account ID दर्ज करें।

    ┌ Enter your Cloudflare Account ID
│
│
└ enter

  4. अपनी Cloudflare API key दर्ज करें।

    ┌ API key
│
│
└ enter

  5. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

    वैकल्पिक रूप से, आप /connect का उपयोग करने के बजाय environment variables सेट कर सकते हैं।

    ~/.bash_profile
    export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_API_KEY=your-api-token

Cortecs

  1. Cortecs console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और Cortecs खोजें।

    /connect

  3. अपनी Cortecs API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Kimi K2 Instruct जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

DeepSeek

  1. DeepSeek console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और Create new API key पर क्लिक करें।

  2. /connect कमांड चलाएँ और DeepSeek खोजें।

    /connect

  3. अपनी DeepSeek API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. DeepSeek V4 Pro जैसे DeepSeek मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Deep Infra

  1. Deep Infra dashboard (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और Deep Infra खोजें।

    /connect

  3. अपनी Deep Infra API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

DigitalOcean

DigitalOcean का Inference Engine (opens in a new tab) GPT-OSS, Llama, Qwen, और DeepSeek जैसे open मॉडलों तक पहुँच प्रदान करता है, साथ ही कस्टम Inference Routers (opens in a new tab) जो प्रत्येक अनुरोध को किसी कार्य के लिए सबसे सस्ते, सबसे तेज़, या सबसे उपयुक्त मॉडल पर रूट करते हैं।

OpenCode दो प्रमाणीकरण विधियों को सपोर्ट करता है:

  • OAuth (अनुशंसित) — अपने DigitalOcean खाते में साइन इन करें; OpenCode inference के लिए सीधे आपके DigitalOcean API token का उपयोग करता है और आपके Inference Routers को खोजता है।
  • Model Access Key — DigitalOcean console से मौजूदा कुंजी पेस्ट करें।

OAuth (अनुशंसित)

  1. /connect कमांड चलाएँ और DigitalOcean खोजें।

    /connect

  2. Login with DigitalOcean चुनें।

    ┌ Select auth method
│
│ Login with DigitalOcean
│ Paste Model Access Key
└

  3. आपका ब्राउज़र OpenCode को अधिकृत करने के लिए खुलता है। साइन इन करें और स्वीकृति दें।

    Note: OpenCode genai:read और inference:query OAuth scopes का अनुरोध करता है। आपका DigitalOcean API token inference के लिए सीधे उपयोग किया जाता है — कोई अलग Model Access Key नहीं बनाया जाता।

    Note: Inference Routers केवल OAuth के बाद मॉडल पिकर में दिखाई देते हैं। Model Access Key को मैन्युअल रूप से पेस्ट करने से routers नहीं खोजे जाते।

  4. /models कमांड चलाएँ। आपके Inference Routers मॉडल चयन में router: प्रारूप के रूप में दिखाई देते हैं।

    /models

  5. नए बनाए गए Inference Routers को लेने के लिए, /connect को फिर से चलाएँ और फिर से DigitalOcean चुनें।

Model Access Key का उपयोग करना

यदि आप कुंजी को सीधे पेस्ट करना पसंद करते हैं:

  1. DigitalOcean console (opens in a new tab) के Inference अनुभाग में Manage पृष्ठ पर जाएँ और एक नई कुंजी बनाएँ।

  2. /connect कमांड चलाएँ और DigitalOcean चुनें, फिर Paste Model Access Key।

    ┌ Enter your DigitalOcean Model Access Key
│
│
└ enter

    Note: इस विधि से Inference Routers स्वतः-खोजे नहीं जाते। उन्हें मॉडल चयनकर्ता में दिखाने के लिए, इसके बजाय OAuth के माध्यम से साइन इन करें।

  3. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

पर्यावरण वेरिएबल

वैकल्पिक रूप से, अपने Model Access Key को एक environment variable के रूप में सेट करें।

export DIGITALOCEAN_ACCESS_TOKEN=your-model-access-key

इन्फ़रेंस राउटर

Inference Routers आपको कई मॉडलों में एक रूटिंग नीति परिभाषित करने देते हैं — कार्य के आधार पर प्रति अनुरोध सबसे सस्ता, सबसे तेज़, या सबसे उपयुक्त मॉडल चुनना। OAuth के बाद, OpenCode प्रत्येक router को मॉडल चयनकर्ता में router:<router-name> के रूप में दिखाता है।

एक router मॉडल चुनना किसी भी अन्य मॉडल के लिए एक drop-in प्रतिस्थापन है — OpenCode आपके अनुरोध को फॉरवर्ड करता है और DigitalOcean आपके router की नीति के आधार पर अंतर्निहित मॉडल चुनता है। Inference Routers (opens in a new tab) के बारे में और जानें

Eden AI

Eden AI (opens in a new tab) यूरोपीय संघ (EU) में स्थित एक गेटवे है, जो एक OpenAI-संगत API के माध्यम से कई प्रदाताओं के मॉडल उपलब्ध कराता है। जिन टीमों को inference EU के अंदर ही रखना है, उनके लिए अलग EU endpoint भी उपलब्ध है।

  1. Eden AI प्लेटफ़ॉर्म (opens in a new tab) पर खाता बनाएँ और API key जनरेट करें।

  2. /connect कमांड चलाएँ और Eden AI खोजें।

    /connect

  3. अपनी Eden AI API key दर्ज करें।

    ┌ API key
│
│
└ enter

  4. /models कमांड चलाकर Mistral Large 3 या Claude Sonnet 5 जैसा मॉडल चुनें।

    /models

    Eden AI के मॉडल ID स्वयं vendor/model प्रारूप में होते हैं, इसलिए पूरे संदर्भ में तीन भाग होते हैं, जैसे edenai/anthropic/claude-sonnet-5।

  5. Eden AI के EU गेटवे का उपयोग करने के लिए उसका base URL सेट करें।

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "edenai": {
      "options": {
        "baseURL": "https://api.eu.edenai.run/v3"
      }
    }
  }
}

    डिफ़ॉल्ट URL https://api.edenai.run/v3 है; यह सेटिंग वैश्विक endpoint को EU endpoint से बदलती है। EU endpoint पर केवल वे catalog मॉडल उपलब्ध हैं जो EU में उपलब्ध हैं, इसलिए चरण 4 में चुना गया मॉडल इस endpoint पर उपलब्ध न भी हो सकता है।

FrogBot

  1. FrogBot dashboard (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और FrogBot खोजें।

    /connect

  3. अपनी FrogBot API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

Fireworks AI

  1. Fireworks AI console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और Create API Key पर क्लिक करें।

  2. /connect कमांड चलाएँ और Fireworks AI खोजें।

    /connect

  3. अपनी Fireworks AI API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Kimi K2 Instruct जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

GitLab Duo

Caution: OpenCode में GitLab Duo सपोर्ट प्रायोगिक है। सुविधाएँ, कॉन्फ़िगरेशन, और व्यवहार भविष्य के रिलीज़ में बदल सकते हैं।

OpenCode GitLab Duo Agent Platform (opens in a new tab) के साथ एकीकृत होता है, जो नेटिव tool calling क्षमताओं के साथ AI-संचालित agentic चैट प्रदान करता है।

Note: GitLab Duo Agent Platform के लिए एक Premium या Ultimate GitLab सदस्यता की आवश्यकता है। यह GitLab.com और GitLab Self-Managed पर उपलब्ध है। पूर्ण आवश्यकताओं के लिए GitLab Duo Agent Platform prerequisites (opens in a new tab) देखें।

  1. /connect कमांड चलाएँ और GitLab का चयन करें।

    /connect

  2. अपनी प्रमाणीकरण विधि चुनें:

    ┌ Select auth method
│
│ OAuth (Recommended)
│ Personal Access Token
└

    OAuth का उपयोग करना (अनुशंसित)

    OAuth चुनें और आपका ब्राउज़र प्राधिकरण के लिए खुलेगा।

    Personal Access Token का उपयोग करना

    1. GitLab User Settings > Access Tokens (opens in a new tab) पर जाएँ
    2. Add new token पर क्लिक करें
    3. Name: OpenCode , Scopes: api
    4. टोकन कॉपी करें ( glpat- से शुरू होता है)
    5. इसे टर्मिनल में दर्ज करें

  3. उपलब्ध मॉडल देखने के लिए /models कमांड चलाएँ।

    /models

    तीन Claude-आधारित मॉडल उपलब्ध हैं:

    • duo-chat-haiku-4-5 (डिफ़ॉल्ट) - त्वरित कार्यों के लिए तेज़ प्रतिक्रियाएँ
    • duo-chat-sonnet-4-5 - अधिकांश वर्कफ़्लो के लिए संतुलित प्रदर्शन
    • duo-chat-opus-4-5 - जटिल विश्लेषण के लिए सबसे सक्षम

Note: यदि आप opencode auth storage में टोकन संग्रहीत नहीं करना चाहते हैं तो आप 'GITLAB_TOKEN' environment variable भी निर्दिष्ट कर सकते हैं।

स्वयं होस्ट किया गया GitLab

Note: OpenCode कुछ AI कार्यों जैसे session title उत्पन्न करने के लिए एक छोटे मॉडल का उपयोग करता है। यह डिफ़ॉल्ट रूप से gpt-5-nano का उपयोग करने के लिए कॉन्फ़िगर किया गया है, जिसे Zen द्वारा होस्ट किया जाता है। OpenCode को केवल आपके स्वयं के GitLab-होस्टेड इंस्टेंस का उपयोग करने के लिए लॉक करने के लिए, अपनी opencode.json फ़ाइल में निम्नलिखित जोड़ें। session sharing को अक्षम करने की भी अनुशंसा की जाती है।

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

Self-hosted GitLab इंस्टेंस के लिए:

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

यदि आपका इंस्टेंस एक कस्टम AI Gateway चलाता है:

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

या अपने bash profile में जोड़ें:

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

Note: आपके GitLab प्रशासक को यह करना होगा:

  1. उपयोगकर्ता, समूह, या इंस्टेंस के लिए GitLab Duo चालू करें (opens in a new tab)
  2. Agent Platform चालू करें (opens in a new tab) (GitLab 18.8+) या beta और प्रायोगिक सुविधाएँ सक्षम करें (opens in a new tab) (GitLab 18.7 और पुराने)
  3. Self-Managed के लिए, अपना इंस्टेंस कॉन्फ़िगर करें (opens in a new tab)
Self-Hosted इंस्टेंस के लिए OAuth

अपने self-hosted इंस्टेंस के लिए OAuth को काम करने के लिए, आपको callback URL http://127.0.0.1:8080/callback और निम्नलिखित scopes के साथ एक नया एप्लिकेशन (Settings → Applications) बनाने की आवश्यकता है:

  • api (आपकी ओर से API तक पहुँच)
  • read_user (आपकी व्यक्तिगत जानकारी पढ़ें)
  • read_repository (रिपॉजिटरी तक केवल-पढ़ने की पहुँच की अनुमति देता है)

फिर application ID को environment variable के रूप में एक्सपोज़ करें:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

opencode-gitlab-auth (opens in a new tab) होमपेज पर अधिक दस्तावेज़।

कॉन्फ़िगरेशन

opencode.json के माध्यम से कस्टमाइज़ करें:

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com"
      }
    }
  }
}
GitLab Duo Agent Platform (DAP) वर्कफ़्लो मॉडल

DAP workflow मॉडल एक वैकल्पिक निष्पादन पथ प्रदान करते हैं जो tool calls को मानक agentic चैट के बजाय GitLab की Duo Workflow Service (DWS) के माध्यम से रूट करता है। जब एक duo-workflow-* मॉडल चुना जाता है, तो OpenCode यह करेगा:

  1. आपके GitLab namespace से उपलब्ध मॉडल खोजना
  2. यदि कई मॉडल उपलब्ध हैं तो एक चयन picker प्रस्तुत करना
  3. तेज़ बाद के स्टार्टअप के लिए चयनित मॉडल को डिस्क पर कैश करना
  4. OpenCode के permission-gated tool सिस्टम के माध्यम से tool निष्पादन अनुरोधों को रूट करना

उपलब्ध DAP workflow मॉडल duo-workflow-* नामकरण परंपरा का पालन करते हैं और आपके GitLab इंस्टेंस से गतिशील रूप से खोजे जाते हैं।

GitLab API Tools (वैकल्पिक, लेकिन अत्यधिक अनुशंसित)

GitLab tools (merge requests, issues, pipelines, CI/CD, आदि) तक पहुँचने के लिए:

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

यह प्लगइन MR reviews, issue tracking, pipeline monitoring, और अधिक सहित व्यापक GitLab रिपॉजिटरी प्रबंधन क्षमताएँ प्रदान करता है।

GitHub Copilot

opencode के साथ अपनी GitHub Copilot सदस्यता का उपयोग करने के लिए:

Note: कुछ मॉडलों को उपयोग करने के लिए एक Pro+ subscription (opens in a new tab) की आवश्यकता हो सकती है।

  1. /connect कमांड चलाएँ और GitHub Copilot खोजें।

    /connect

  2. github.com/login/device (opens in a new tab) पर नेविगेट करें और कोड दर्ज करें।

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

  3. अब अपना इच्छित मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

GMI Cloud

OpenCode के साथ GMI Cloud का उपयोग करने के लिए:

  1. एक API कुंजी बनाने के लिए GMI Cloud console (opens in a new tab) पर जाएँ। आप एंडपॉइंट विवरण के लिए API संदर्भ (opens in a new tab) भी देख सकते हैं।

  2. /connect कमांड चलाएँ और GMI Cloud खोजें।

    /connect

  3. अपनी GMI Cloud API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. अपना इच्छित मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

Google Vertex AI

OpenCode के साथ Google Vertex AI का उपयोग करने के लिए:

  1. Google Cloud Console में Model Garden पर जाएँ और अपने क्षेत्र में उपलब्ध मॉडलों की जाँच करें।

    Note: आपके पास Vertex AI API सक्षम वाला एक Google Cloud project होना चाहिए।

  2. आवश्यक environment variables सेट करें:

    • GOOGLE_CLOUD_PROJECT : आपका Google Cloud project ID

    • VERTEX_LOCATION (वैकल्पिक): Vertex AI के लिए क्षेत्र (डिफ़ॉल्ट global )

    • प्रमाणीकरण (एक चुनें):

      • GOOGLE_APPLICATION_CREDENTIALS : आपकी service account JSON key फ़ाइल का पथ
      • gcloud CLI का उपयोग करके प्रमाणित करें: gcloud auth application-default login

    opencode चलाते समय उन्हें सेट करें।

    GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode

    या उन्हें अपने bash profile में जोड़ें।

    ~/.bash_profile
    export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global

Tip: global क्षेत्र बिना किसी अतिरिक्त लागत के उपलब्धता में सुधार करता है और त्रुटियों को कम करता है। डेटा रेज़िडेंसी आवश्यकताओं के लिए क्षेत्रीय एंडपॉइंट (जैसे, us-central1) का उपयोग करें। और जानें (opens in a new tab)

  1. अपना इच्छित मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

Groq

  1. Groq console (opens in a new tab) पर जाएँ, Create API Key पर क्लिक करें, और कुंजी कॉपी करें।

  2. /connect कमांड चलाएँ और Groq खोजें।

    /connect

  3. प्रदाता के लिए API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. अपना इच्छित मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

Hugging Face

Hugging Face Inference Providers (opens in a new tab) 17+ प्रदाताओं द्वारा समर्थित open मॉडलों तक पहुँच प्रदान करता है।

  1. Inference Providers को कॉल करने की अनुमति वाला एक टोकन बनाने के लिए Hugging Face settings (opens in a new tab) पर जाएँ।

  2. /connect कमांड चलाएँ और Hugging Face खोजें।

    /connect

  3. अपना Hugging Face टोकन दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Kimi-K2-Instruct या GLM-4.6 जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Helicone

Helicone (opens in a new tab) एक LLM observability प्लेटफ़ॉर्म है जो आपके AI एप्लिकेशनों के लिए logging, monitoring, और analytics प्रदान करता है। Helicone AI Gateway मॉडल के आधार पर आपके अनुरोधों को स्वचालित रूप से उपयुक्त प्रदाता पर रूट करता है।

  1. Helicone (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और अपने dashboard से एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और Helicone खोजें।

    /connect

  3. अपनी Helicone API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

अधिक प्रदाताओं और caching तथा rate limiting जैसी उन्नत सुविधाओं के लिए, Helicone documentation (opens in a new tab) देखें।

वैकल्पिक कॉन्फ़िग

यदि आप Helicone की कोई ऐसी सुविधा या मॉडल देखते हैं जो opencode के माध्यम से स्वचालित रूप से कॉन्फ़िगर नहीं है, तो आप इसे हमेशा स्वयं कॉन्फ़िगर कर सकते हैं।

यहाँ Helicone's Model Directory (opens in a new tab) है, आपको उन मॉडलों के ID प्राप्त करने के लिए इसकी आवश्यकता होगी जिन्हें आप जोड़ना चाहते हैं।

~/.config/opencode/opencode.jsonc
{
  "$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 caching, user tracking, और session management जैसी सुविधाओं के लिए custom headers का समर्थन करता है। उन्हें options.headers का उपयोग करके अपनी प्रदाता कॉन्फ़िग में जोड़ें:

~/.config/opencode/opencode.jsonc
{
  "$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 की Sessions (opens in a new tab) सुविधा आपको संबंधित LLM अनुरोधों को एक साथ समूहित करने देती है। प्रत्येक OpenCode वार्तालाप को Helicone में एक session के रूप में स्वचालित रूप से लॉग करने के लिए opencode-helicone-session (opens in a new tab) प्लगइन का उपयोग करें।

npm install -g opencode-helicone-session

इसे अपनी कॉन्फ़िग में जोड़ें।

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

प्लगइन आपके अनुरोधों में Helicone-Session-Id और Helicone-Session-Name headers इंजेक्ट करता है। Helicone के Sessions पृष्ठ में, आप प्रत्येक OpenCode वार्तालाप को एक अलग session के रूप में सूचीबद्ध देखेंगे।

सामान्य Helicone headers
Headerविवरण
Helicone-Cache-Enabledप्रतिक्रिया caching सक्षम करें (true/false)
Helicone-User-Idउपयोगकर्ता के अनुसार मेट्रिक्स ट्रैक करें
Helicone-Property-[Name]कस्टम गुण जोड़ें (जैसे, Helicone-Property-Environment)
Helicone-Prompt-Idअनुरोधों को prompt संस्करणों के साथ संबद्ध करें

सभी उपलब्ध headers के लिए Helicone Header Directory (opens in a new tab) देखें।

llama.cpp

आप opencode को llama.cpp's (opens in a new tab) llama-server उपयोगिता के माध्यम से स्थानीय मॉडलों का उपयोग करने के लिए कॉन्फ़िगर कर सकते हैं

opencode.json
{
  "$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 इस प्रदाता के लिए उपयोग किए जाने वाले पैकेज को निर्दिष्ट करता है। यहाँ, किसी भी OpenAI-संगत API के लिए @ai-sdk/openai-compatible का उपयोग किया जाता है।
  • name UI में प्रदाता के लिए प्रदर्शन नाम है।
  • options.baseURL स्थानीय सर्वर के लिए एंडपॉइंट है।
  • models मॉडल ID से उनके कॉन्फ़िगरेशन का एक मैप है। मॉडल नाम मॉडल चयन सूची में प्रदर्शित होगा।

IO.NET

IO.NET विभिन्न उपयोग के मामलों के लिए अनुकूलित 17 मॉडल प्रदान करता है:

  1. IO.NET console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और IO.NET खोजें।

    /connect

  3. अपनी IO.NET API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

LM Studio

आप opencode को LM Studio के माध्यम से स्थानीय मॉडलों का उपयोग करने के लिए कॉन्फ़िगर कर सकते हैं।

opencode.json
{
  "$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 इस प्रदाता के लिए उपयोग किए जाने वाले पैकेज को निर्दिष्ट करता है। यहाँ, किसी भी OpenAI-संगत API के लिए @ai-sdk/openai-compatible का उपयोग किया जाता है।
  • name UI में प्रदाता के लिए प्रदर्शन नाम है।
  • options.baseURL स्थानीय सर्वर के लिए एंडपॉइंट है।
  • models मॉडल ID से उनके कॉन्फ़िगरेशन का एक मैप है। मॉडल नाम मॉडल चयन सूची में प्रदर्शित होगा।

Moonshot AI

Moonshot AI से Kimi K2 का उपयोग करने के लिए:

  1. Moonshot AI console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और Create API key पर क्लिक करें।

  2. /connect कमांड चलाएँ और Moonshot AI खोजें।

    /connect

  3. अपनी Moonshot API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Kimi K2 चुनने के लिए /models कमांड चलाएँ।

    /models

MiniMax

  1. MiniMax API Console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और MiniMax खोजें।

    /connect

  3. अपनी MiniMax API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. M2.1 जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Modal

  1. उपयोग किए जाने वाले model के लिए shared Endpoint (opens in a new tab) बनाएँ।

  2. proxy token (opens in a new tab) बनाएँ और उसके ID व secret को period से जोड़ें:

    wk-<id>.ws-<secret>

  3. /connect चलाएँ, Modal खोजें और संयुक्त proxy token दर्ज करें।

    /connect

  4. Modal workspace का endpoint चुनने के लिए /models चलाएँ।

    /models

NVIDIA

NVIDIA build.nvidia.com (opens in a new tab) के माध्यम से Nemotron मॉडलों और कई अन्य open मॉडलों तक मुफ़्त पहुँच प्रदान करता है।

  1. build.nvidia.com (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और NVIDIA खोजें।

    /connect

  3. अपनी NVIDIA API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. nemotron-3-super-120b-a12b जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

स्थानीय डिप्लॉयमेंट / NIM

आप एक कस्टम base URL सेट करके NVIDIA NIM (opens in a new tab) के माध्यम से NVIDIA मॉडलों का स्थानीय रूप से भी उपयोग कर सकते हैं।

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "nvidia": {
      "options": {
        "baseURL": "http://localhost:8000/v1"
      }
    }
  }
}

पर्यावरण वेरिएबल

वैकल्पिक रूप से, अपनी API कुंजी को एक environment variable के रूप में सेट करें।

export NVIDIA_API_KEY=nvapi-your-key-here

Nebius Token Factory

  1. Nebius Token Factory console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और Add Key पर क्लिक करें।

  2. /connect कमांड चलाएँ और Nebius Token Factory खोजें।

    /connect

  3. अपनी Nebius Token Factory API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Kimi K2 Instruct जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Ollama

आप opencode को Ollama के माध्यम से स्थानीय मॉडलों का उपयोग करने के लिए कॉन्फ़िगर कर सकते हैं।

Tip: Ollama OpenCode के लिए स्वचालित रूप से स्वयं को कॉन्फ़िगर कर सकता है। विवरण के लिए Ollama integration docs (opens in a new tab) देखें।

opencode.json
{
  "$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 इस प्रदाता के लिए उपयोग किए जाने वाले पैकेज को निर्दिष्ट करता है। यहाँ, किसी भी OpenAI-संगत API के लिए @ai-sdk/openai-compatible का उपयोग किया जाता है।
  • name UI में प्रदाता के लिए प्रदर्शन नाम है।
  • options.baseURL स्थानीय सर्वर के लिए एंडपॉइंट है।
  • models मॉडल ID से उनके कॉन्फ़िगरेशन का एक मैप है। मॉडल नाम मॉडल चयन सूची में प्रदर्शित होगा।

Tip: यदि tool calls काम नहीं कर रहे हैं, तो Ollama में num_ctx बढ़ाने का प्रयास करें। लगभग 16k - 32k से शुरू करें।

Ollama Cloud

OpenCode के साथ Ollama Cloud का उपयोग करने के लिए:

  1. https://ollama.com/ (opens in a new tab) पर जाएँ और साइन इन करें या एक खाता बनाएँ।

  2. Settings > Keys पर नेविगेट करें और एक नई API कुंजी उत्पन्न करने के लिए Add API Key पर क्लिक करें।

  3. OpenCode में उपयोग के लिए API कुंजी कॉपी करें।

  4. /connect कमांड चलाएँ और Ollama Cloud खोजें।

    /connect

  5. अपनी Ollama Cloud API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  6. महत्वपूर्ण: OpenCode में cloud मॉडलों का उपयोग करने से पहले, आपको मॉडल जानकारी को स्थानीय रूप से pull करना होगा:

    ollama pull gpt-oss:20b-cloud

  7. अपना Ollama Cloud मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

OpenAI

हम ChatGPT Plus या Pro (opens in a new tab) के लिए साइन अप करने की अनुशंसा करते हैं।

  1. एक बार जब आप साइन अप कर लेते हैं, तो /connect कमांड चलाएँ और OpenAI का चयन करें।

    /connect

  2. यहाँ आप ChatGPT Plus/Pro विकल्प चुन सकते हैं और यह आपका ब्राउज़र खोलेगा और आपसे प्रमाणित करने के लिए कहेगा।

    ┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└

  3. अब /models कमांड का उपयोग करते समय सभी OpenAI मॉडल उपलब्ध होने चाहिए।

    /models
कंप्यूट क्षेत्र

ChatGPT OAuth में, workspace credentials द्वारा regional inference residency बताए जाने पर OpenCode उसे अपने आप लागू करता है। यह निश्चित regions सूची रखने के बजाय credential का compute residency मान forward करता है। Data residency at rest का अर्थ regional inference नहीं है।

API keys का उपयोग करना

यदि आपके पास पहले से एक API कुंजी है, तो आप Manually enter API Key चुन सकते हैं और इसे अपने टर्मिनल में पेस्ट कर सकते हैं।

OpenCode Zen

OpenCode Zen OpenCode टीम द्वारा प्रदान किए गए परीक्षित और सत्यापित मॉडलों की एक सूची है। और जानें।

  1. OpenCode Zen (opens in a new tab) में साइन इन करें और Create API Key पर क्लिक करें।

  2. /connect कमांड चलाएँ और OpenCode Zen खोजें।

    /connect

  3. अपनी OpenCode API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Qwen 3 Coder 480B जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

OpenRouter

  1. OpenRouter dashboard (opens in a new tab) पर जाएँ, Create API Key पर क्लिक करें, और कुंजी कॉपी करें।

  2. /connect कमांड चलाएँ और OpenRouter खोजें।

    /connect

  3. प्रदाता के लिए API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. कई OpenRouter मॉडल डिफ़ॉल्ट रूप से preloaded होते हैं, अपना इच्छित मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

    आप अपनी opencode कॉन्फ़िग के माध्यम से अतिरिक्त मॉडल भी जोड़ सकते हैं।

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}

  5. आप उन्हें अपनी opencode कॉन्फ़िग के माध्यम से भी कस्टमाइज़ कर सकते हैं। यहाँ एक प्रदाता निर्दिष्ट करने का उदाहरण है

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

LLM Gateway

  1. LLM Gateway dashboard (opens in a new tab) पर जाएँ, Create API Key पर क्लिक करें, और कुंजी कॉपी करें।

  2. /connect कमांड चलाएँ और LLM Gateway खोजें।

    /connect

  3. प्रदाता के लिए API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. कई LLM Gateway मॉडल डिफ़ॉल्ट रूप से preloaded होते हैं, अपना इच्छित मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

    आप अपनी opencode कॉन्फ़िग के माध्यम से अतिरिक्त मॉडल भी जोड़ सकते हैं।

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llmgateway": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}

  5. आप उन्हें अपनी opencode कॉन्फ़िग के माध्यम से भी कस्टमाइज़ कर सकते हैं। यहाँ एक प्रदाता निर्दिष्ट करने का उदाहरण है

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llmgateway": {
      "models": {
        "glm-4.7": {
          "name": "GLM 4.7"
        },
        "gpt-5.2": {
          "name": "GPT-5.2"
        },
        "gemini-2.5-pro": {
          "name": "Gemini 2.5 Pro"
        },
        "claude-3-5-sonnet-20241022": {
          "name": "Claude 3.5 Sonnet"
        }
      }
    }
  }
}

Poolside

Poolside (opens in a new tab) OpenAI-compatible API के माध्यम से अपने models उपलब्ध कराता है।

  1. platform.poolside.ai (opens in a new tab) में sign in करें, API Keys tab खोलें और New key पर क्लिक करके API key बनाएँ।

  2. /connect चलाएँ और Poolside खोजें।

    /connect

  3. Poolside API key दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Model चुनने के लिए /models चलाएँ।

    /models

Poolside डिप्लॉयमेंट

यदि आपका संगठन Poolside deployment चलाता है, तो उसे custom OpenAI-compatible provider के रूप में कॉन्फ़िगर करें। Administrator से मिली API key या token को ~/.secrets/poolside-key में रखें, अलग provider ID इस्तेमाल करें और उपलब्ध model IDs जोड़ें।

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "poolside-deployment": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Poolside deployment",
      "options": {
        "baseURL": "https://poolside.example.com/openai/v1",
        "apiKey": "{file:~/.secrets/poolside-key}"
      },
      "models": {
        "<served-model-id>": {
          "name": "Poolside deployment model",
          "reasoning": true,
          "interleaved": {
            "field": "reasoning_content"
          }
        }
      }
    }
  }
}

poolside.example.com को deployment host और <served-model-id> को /openai/v1/models endpoint से मिले model ID से बदलें। Model availability और thinking behavior deployment configuration पर निर्भर हैं।

Tip: Terminal से Poolside agents सीधे उपयोग करने के लिए Poolside Agent CLI (opens in a new tab) भी इंस्टॉल कर सकते हैं।

SAP AI Core

SAP AI Core एक एकीकृत प्लेटफ़ॉर्म के माध्यम से OpenAI, Anthropic, Google, Amazon, Meta, Mistral, और AI21 से 40+ मॉडलों तक पहुँच प्रदान करता है।

  1. अपने SAP BTP Cockpit (opens in a new tab) पर जाएँ, अपने SAP AI Core service instance पर नेविगेट करें, और एक service key बनाएँ।

    Tip: service key एक JSON ऑब्जेक्ट है जिसमें clientid, clientsecret, url, और serviceurls.AI_API_URL शामिल हैं। आप अपने AI Core instance को BTP Cockpit में Services > Instances and Subscriptions के अंतर्गत पा सकते हैं।

  2. /connect कमांड चलाएँ और SAP AI Core खोजें।

    /connect

  3. अपना service key JSON दर्ज करें।

    ┌ Service key
│
│
└ enter

    या AICORE_SERVICE_KEY environment variable सेट करें:

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

    या इसे अपने bash profile में जोड़ें:

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

  4. वैकल्पिक रूप से deployment ID और resource group सेट करें:

    AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode

    Note: ये सेटिंग्स वैकल्पिक हैं और इन्हें आपके SAP AI Core सेटअप के अनुसार कॉन्फ़िगर किया जाना चाहिए।

  5. 40+ उपलब्ध मॉडलों में से चुनने के लिए /models कमांड चलाएँ।

    /models

STACKIT

STACKIT AI Model Serving AI मॉडलों के लिए एक पूरी तरह से प्रबंधित संप्रभु होस्टिंग वातावरण प्रदान करता है, जो Llama, Mistral, और Qwen जैसे LLM पर ध्यान केंद्रित करता है, यूरोपीय बुनियादी ढाँचे पर अधिकतम डेटा संप्रभुता के साथ।

  1. STACKIT Portal (opens in a new tab) पर जाएँ, AI Model Serving पर नेविगेट करें, और अपने प्रोजेक्ट के लिए एक auth token बनाएँ।

    Tip: auth tokens बनाने से पहले आपको एक STACKIT customer account, user account, और project की आवश्यकता है।

  2. /connect कमांड चलाएँ और STACKIT खोजें।

    /connect

  3. अपना STACKIT AI Model Serving auth token दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Qwen3-VL 235B या Llama 3.3 70B जैसे उपलब्ध मॉडलों में से चुनने के लिए /models कमांड चलाएँ।

    /models

OVHcloud AI Endpoints

  1. OVHcloud panel (opens in a new tab) पर जाएँ। Public Cloud अनुभाग, AI & Machine Learning > AI Endpoints पर नेविगेट करें और API Keys टैब में, Create a new API key पर क्लिक करें।

  2. /connect कमांड चलाएँ और OVHcloud AI Endpoints खोजें।

    /connect

  3. अपनी OVHcloud AI Endpoints API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. gpt-oss-120b जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Scaleway

Opencode के साथ Scaleway Generative APIs (opens in a new tab) का उपयोग करने के लिए:

  1. एक नई API कुंजी उत्पन्न करने के लिए Scaleway Console IAM settings (opens in a new tab) पर जाएँ।

  2. /connect कमांड चलाएँ और Scaleway खोजें।

    /connect

  3. अपनी Scaleway API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. devstral-2-123b-instruct-2512 या gpt-oss-120b जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

SCX.ai

SCX.ai (opens in a new tab) ऑस्ट्रेलिया का sovereign AI platform है, जो ऑस्ट्रेलिया में renewable-energy infrastructure पर OpenAI-compatible API से open models देता है।

  1. SCX.ai platform (opens in a new tab) पर account और API key बनाएँ।

  2. /connect चलाएँ और SCX.ai खोजें।

    /connect

  3. SCX.ai API key दर्ज करें।

    ┌ API key
│
│
└ enter

  4. MiniMax-M2.7 या GLM-5.2 जैसा model चुनने के लिए /models चलाएँ।

    /models

Snowflake Cortex

Snowflake Cortex (opens in a new tab) एक OpenAI-संगत API के माध्यम से आपको frontier मॉडलों (Claude, OpenAI GPT-5, और अधिक) तक पहुँच देता है। सभी inference Snowflake perimeter के भीतर चलता है और Snowflake credits में बिल किया जाता है। प्रति-मॉडल दरों के लिए, Snowflake Service Consumption Table (opens in a new tab) देखें।

क्या आपके पास Snowflake खाता नहीं है? मुफ़्त ट्रायल के लिए साइन अप करें (opens in a new tab)।

कोडिंग, फ़ाइल संपादन, और कमांड चलाने के लिए opencode का मुख्य वर्कफ़्लो tool calling पर निर्भर करता है। Snowflake Cortex के भीतर केवल Claude और OpenAI परिवार इसका समर्थन करते हैं। मुख्य वर्कफ़्लो का समर्थन करने के लिए प्रदाता उन्हीं परिवारों तक सीमित है।

OpenCode दो प्रमाणीकरण विधियों को सपोर्ट करता है:

  • Browser OAuth (अनुशंसित) — अपने IdP/SSO के साथ साइन इन करें; कोई secrets प्रबंधित नहीं करने होते, टोकन स्वचालित रूप से रीफ़्रेश होते हैं।
  • Manual bearer token — Snowflake console से एक PAT या JWT पेस्ट करें।

Browser OAuth (अनुशंसित)

  1. /connect कमांड चलाएँ और Snowflake Cortex खोजें।

    /connect

  2. Login with Snowflake (External Browser) चुनें।

    ┌ Select auth method
│
│ Login with Snowflake (External Browser)
│ Paste PAT or bearer token manually
└

  3. संकेत मिलने पर अपना account identifier (opens in a new tab) दर्ज करें, उदाहरण के लिए myorg-myaccount या xy12345.us-east-1।

    ┌ Snowflake Account Identifier
│
│
└ enter

  4. वैकल्पिक रूप से सत्र को scope करने के लिए एक Snowflake role दर्ज करें (जैसे SYSADMIN)। अपनी डिफ़ॉल्ट role का उपयोग करने के लिए खाली छोड़ दें।

  5. खुलने वाले ब्राउज़र में साइन-इन पूरा करें। OpenCode OAuth callback को स्वचालित रूप से कैप्चर करता है और टोकन संग्रहीत करता है — किसी कॉपी/पेस्ट की आवश्यकता नहीं।

  6. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

Note: Browser OAuth Snowflake के बिल्ट-इन SNOWFLAKE$LOCAL_APPLICATION सिक्योरिटी इंटीग्रेशन (docs (opens in a new tab)) का उपयोग करता है, जो सभी खातों में रोलआउट हो रहा है। अपने खाते में उपलब्धता जाँचने के लिए:

SHOW SECURITY INTEGRATIONS LIKE 'SNOWFLAKE$LOCAL_APPLICATION';

यदि परिणाम खाली है, तो जब तक इंटीग्रेशन आपके खाते में रोलआउट हो रहा है तब तक नीचे दी गई Manual bearer token विधि का उपयोग करें।

मैन्युअल Bearer टोकन

यदि आप सीधे एक टोकन पेस्ट करना पसंद करते हैं, या यदि आपके खाते में SNOWFLAKE$LOCAL_APPLICATION अभी तक उपलब्ध नहीं है:

  1. अपने Snowflake खाते में एक Programmatic Access Token (PAT) (opens in a new tab) उत्पन्न करें।

  2. /connect कमांड चलाएँ, Snowflake Cortex खोजें, और Paste PAT or bearer token manually चुनें।

  3. संकेत मिलने पर अपना account identifier (opens in a new tab) दर्ज करें।

  4. अपना PAT पेस्ट करें।

  5. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

पर्यावरण वेरिएबल

CI या headless वातावरण के लिए, opencode शुरू करने से पहले एक PAT या JWT सेट करें:

export SNOWFLAKE_ACCOUNT=myorg-myaccount
export SNOWFLAKE_CORTEX_TOKEN=your-pat-or-jwt

Note: SNOWFLAKE_CORTEX_TOKEN केवल PAT या JWT स्वीकार करता है — browser OAuth फ़्लो केवल /connect के माध्यम से उपलब्ध है और इसे environment variable के माध्यम से कॉन्फ़िगर नहीं किया जा सकता। बैकवर्ड संगतता के लिए SNOWFLAKE_CORTEX_PAT अभी भी समर्थित है।

मॉडल कैटलॉग स्वचालित रूप से प्रदान किया जाता है। केवल एक न्यूनतम opencode.json की आवश्यकता है:

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "model": "snowflake-cortex/claude-sonnet-4-6",
  "small_model": "snowflake-cortex/claude-haiku-4-5"
}

Together AI

  1. Together AI console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और Add Key पर क्लिक करें।

  2. /connect कमांड चलाएँ और Together AI खोजें।

    /connect

  3. अपनी Together AI API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Kimi K2 Instruct जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Venice AI

  1. Venice AI console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और एक API कुंजी उत्पन्न करें।

  2. /connect कमांड चलाएँ और Venice AI खोजें।

    /connect

  3. अपनी Venice AI API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. Llama 3.3 70B जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

Vercel AI Gateway

Vercel AI Gateway आपको एक एकीकृत एंडपॉइंट के माध्यम से OpenAI, Anthropic, Google, xAI, और अधिक से मॉडलों तक पहुँचने देता है। मॉडल बिना किसी markup के list price पर पेश किए जाते हैं।

  1. Vercel dashboard (opens in a new tab) पर जाएँ, AI Gateway टैब पर नेविगेट करें, और एक नई API कुंजी बनाने के लिए API keys पर क्लिक करें।

  2. /connect कमांड चलाएँ और Vercel AI Gateway खोजें।

    /connect

  3. अपनी Vercel AI Gateway API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. एक मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

आप अपनी opencode कॉन्फ़िग के माध्यम से भी मॉडल कस्टमाइज़ कर सकते हैं। यहाँ provider routing order निर्दिष्ट करने का एक उदाहरण है।

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

कुछ उपयोगी routing विकल्प:

विकल्पविवरण
orderप्रयास करने के लिए प्रदाता अनुक्रम
onlyविशिष्ट प्रदाताओं तक सीमित करें
zeroDataRetentionकेवल शून्य data retention नीतियों वाले प्रदाताओं का उपयोग करें

xAI

Authentication के दो तरीके हैं: device-code OAuth से SuperGrok subscription या xAI console की pay-as-you-go API key।

विकल्प A — SuperGrok subscription

  1. /connect चलाएँ और xAI खोजें।

    /connect

  2. SuperGrok Subscription चुनें। समर्थित होने पर OpenCode पहले से भरे user code वाला xAI verification link खोलता है।

  3. Consent screen approve करें। xAI code माँगे तो OpenCode द्वारा दिखाया user code दर्ज करें। Approval के बाद OpenCode xAI token endpoint poll करता और OAuth tokens सहेजता है।

  4. Grok model चुनने के लिए /models चलाएँ।

    /models

OpenCode OAuth access token अपने आप refresh करता है। Grok API access वाला कोई भी Grok या X Premium plan काम करता है; अलग XAI_API_KEY की जरूरत नहीं।

विकल्प B — API key

  1. xAI console (opens in a new tab) पर account और API key बनाएँ।

  2. /connect चलाएँ और xAI खोजें।

    /connect

  3. Manually enter API Key चुनें और xAI API key paste करें।

    ┌ API key
│
│
└ enter

  4. Grok Beta जैसा model चुनने के लिए /models चलाएँ।

    /models

Z.AI

  1. Z.AI API console (opens in a new tab) पर जाएँ, एक खाता बनाएँ, और Create a new API key पर क्लिक करें।

  2. /connect कमांड चलाएँ और Z.AI खोजें।

    /connect

    यदि आप GLM Coding Plan के सदस्य हैं, तो Z.AI Coding Plan चुनें।

  3. अपनी Z.AI API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. GLM-4.7 जैसे मॉडल को चुनने के लिए /models कमांड चलाएँ।

    /models

ZenMux

  1. ZenMux dashboard (opens in a new tab) पर जाएँ, Create API Key पर क्लिक करें, और कुंजी कॉपी करें।

  2. /connect कमांड चलाएँ और ZenMux खोजें।

    /connect

  3. प्रदाता के लिए API कुंजी दर्ज करें।

    ┌ API key
│
│
└ enter

  4. कई ZenMux मॉडल डिफ़ॉल्ट रूप से preloaded होते हैं, अपना इच्छित मॉडल चुनने के लिए /models कमांड चलाएँ।

    /models

    आप अपनी opencode कॉन्फ़िग के माध्यम से अतिरिक्त मॉडल भी जोड़ सकते हैं।

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}

कस्टम प्रदाता

किसी भी OpenAI-संगत प्रदाता को जोड़ने के लिए जो /connect कमांड में सूचीबद्ध नहीं है:

Tip: आप opencode के साथ किसी भी OpenAI-संगत प्रदाता का उपयोग कर सकते हैं। अधिकांश आधुनिक AI प्रदाता OpenAI-संगत API प्रदान करते हैं।

  1. /connect कमांड चलाएँ और Other तक नीचे स्क्रॉल करें।

    $ /connect
 
┌  Add credential
│
◆  Select provider
│  ...
│  ● Other
└

  2. प्रदाता के लिए एक अद्वितीय ID दर्ज करें।

    $ /connect
 
┌  Add credential
│
◇  Enter provider id
│  myprovider
└

    Note: एक यादगार ID चुनें, आप इसका उपयोग अपनी कॉन्फ़िग फ़ाइल में करेंगे।

  3. प्रदाता के लिए अपनी 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-...
└

  4. अपनी प्रोजेक्ट निर्देशिका में अपनी opencode.json फ़ाइल बनाएँ या अपडेट करें:

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI Provider Display Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}

    यहाँ कॉन्फ़िगरेशन विकल्प हैं:

    • npm : उपयोग करने के लिए AI SDK पैकेज, OpenAI-संगत प्रदाताओं के लिए @ai-sdk/openai-compatible ( /v1/chat/completions के लिए)। यदि आपका प्रदाता/मॉडल /v1/responses का उपयोग करता है, तो @ai-sdk/openai का उपयोग करें।
    • name : UI में प्रदर्शन नाम।
    • models : उपलब्ध मॉडल।
    • options.baseURL : API एंडपॉइंट URL।
    • options.apiKey : वैकल्पिक रूप से API कुंजी सेट करें, यदि auth का उपयोग नहीं कर रहे हैं।
    • options.headers : वैकल्पिक रूप से custom headers सेट करें।

    नीचे दिए गए उदाहरण में उन्नत विकल्पों के बारे में अधिक।

  5. /models कमांड चलाएँ और आपका कस्टम प्रदाता और मॉडल चयन सूची में दिखाई देंगे।

उदाहरण

यहाँ apiKey, headers, और मॉडल limit विकल्पों को सेट करने का एक उदाहरण है।

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI Provider Display 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 variable सिंटैक्स का उपयोग करके सेट करें, और जानें ।
  • headers : प्रत्येक अनुरोध के साथ भेजे जाने वाले custom headers।
  • limit.context : मॉडल द्वारा स्वीकार किए जाने वाले अधिकतम input tokens।
  • limit.output : मॉडल द्वारा उत्पन्न किए जा सकने वाले अधिकतम tokens।

limit फ़ील्ड OpenCode को यह समझने की अनुमति देते हैं कि आपके पास कितना context बचा है। मानक प्रदाता इन्हें models.dev से स्वचालित रूप से प्राप्त करते हैं।

समस्या निवारण

यदि आपको किसी प्रदाता को कॉन्फ़िगर करने में परेशानी हो रही है, तो निम्नलिखित की जाँच करें:

  1. auth सेटअप की जाँच करें: यह देखने के लिए कि प्रदाता के लिए credentials आपकी कॉन्फ़िग में जोड़े गए हैं या नहीं, opencode auth list चलाएँ। यह Amazon Bedrock जैसे प्रदाताओं पर लागू नहीं होता, जो अपने auth के लिए environment variables पर निर्भर करते हैं।

  2. कस्टम प्रदाताओं के लिए, opencode कॉन्फ़िग की जाँच करें और:

    • सुनिश्चित करें कि /connect कमांड में उपयोग किया गया प्रदाता ID आपकी opencode कॉन्फ़िग में ID से मेल खाता है।
    • प्रदाता के लिए सही npm पैकेज का उपयोग किया गया है। उदाहरण के लिए, Cerebras के लिए @ai-sdk/cerebras का उपयोग करें। और अन्य सभी OpenAI-संगत प्रदाताओं के लिए, @ai-sdk/openai-compatible का उपयोग करें ( /v1/chat/completions के लिए); यदि कोई मॉडल /v1/responses का उपयोग करता है, तो @ai-sdk/openai का उपयोग करें। एक प्रदाता के अंतर्गत मिश्रित सेटअप के लिए, आप provider.npm के माध्यम से प्रति मॉडल ओवरराइड कर सकते हैं।
    • जाँचें कि options.baseURL फ़ील्ड में सही API एंडपॉइंट का उपयोग किया गया है।
कॉन्फ़िगरेशननेटवर्क

दस्तावेज़ का स्रोत (MIT)