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

प्रदाता

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

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

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

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

Credentials

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

Config

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

Base URL

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

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

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 में किसी भी अन्य प्रदाता की तरह काम करता है और उपयोग करना पूरी तरह से वैकल्पिक है।

OpenCode Go

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

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

    /connect

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

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

    ┌ API key
│
│
└ enter

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

    /models

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

Directory

आइए कुछ प्रदाताओं को विस्तार से देखें। यदि आप सूची में कोई प्रदाता जोड़ना चाहते हैं, तो बेझिझक एक 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

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 स्वचालित रूप से एक Model Access Key बनाता है और आपके उपलब्ध Models & 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 आपके DigitalOcean खाते में opencode-oauth-<timestamp> नामक एक Model Access Key बनाता है। आप इसे Inference के अंतर्गत DigitalOcean console के "Manage" अनुभाग में Model Access Keys पृष्ठ से रोटेट या रद्द कर सकते हैं।

  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

Environment Variable

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

export DIGITALOCEAN_ACCESS_TOKEN=your-model-access-key

Inference Routers

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

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

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 भी निर्दिष्ट कर सकते हैं।

Self-Hosted 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) होमपेज पर अधिक दस्तावेज़।

Configuration

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

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com"
      }
    }
  }
}
GitLab Duo Agent Platform (DAP) Workflow Models

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

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

Custom Headers

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",
        },
      },
    },
  },
}
Session tracking

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

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

On-Prem / 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"
      }
    }
  }
}

Environment Variable

वैकल्पिक रूप से, अपनी 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
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"
        }
      }
    }
  }
}

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

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

प्रमाणित करने के तीन तरीके: ब्राउज़र OAuth के माध्यम से एक SuperGrok सदस्यता, उसी SuperGrok सदस्यता के माध्यम से एक headless device-code flow (VPS / SSH / Docker के लिए), या xAI console से एक pay-as-you-go API कुंजी।

Option A — SuperGrok OAuth (browser login)

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

    /connect

  2. xAI Grok OAuth (SuperGrok Subscription) चुनें। OpenCode आपके ब्राउज़र में xAI की consent screen खोलता है और http://127.0.0.1:56121/callback पर callback की प्रतीक्षा करता है।

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

    /models

OpenCode OAuth access token को स्वचालित रूप से रीफ़्रेश करता है। कोई भी Grok या X Premium प्लान जिसमें Grok API पहुँच शामिल है, काम करता है; आपको एक अलग XAI_API_KEY की आवश्यकता नहीं है।

Option B — SuperGrok device-code (headless / remote server / VPS)

इसका उपयोग तब करें जब OpenCode कहीं ऐसी जगह चल रहा हो जहाँ ब्राउज़र loopback redirect तक नहीं पहुँच सकता: एक VPS, SSH के माध्यम से एक रिमोट डेव बॉक्स, Docker के अंदर, CI में, आदि। OpenCode चलाने वाले host पर कोई callback port नहीं खोला जाता — इसके बजाय xAI CLI को एक छोटा कोड देता है जिसे आप किसी भी अन्य डिवाइस (लैपटॉप, फ़ोन, ...) पर ब्राउज़र में टाइप करते हैं।

  1. रिमोट host पर /connect कमांड चलाएँ और xAI खोजें।

    /connect

  2. xAI Grok OAuth (Headless / Remote / VPS) चुनें। OpenCode एक verification URL और एक छोटा user code प्रिंट करता है।

    Open https://x.ai/device on any device and enter code: ABCD-1234

  3. किसी ऐसे डिवाइस पर URL खोलें जिसमें ब्राउज़र हो (आपका लैपटॉप या फ़ोन), कोड दर्ज करें, और consent screen को स्वीकृति दें। OpenCode xAI के token endpoint को poll करता है और एक बार आपके स्वीकृति देने पर परिणामी OAuth tokens संग्रहीत करता है। Token refresh Option A की तरह ही काम करता है।

Option C — API key

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

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

    /connect

  3. Manually enter API Key चुनें और अपनी xAI API कुंजी पेस्ट करें।

    ┌ API key
│
│
└ enter

  4. Grok Beta जैसे मॉडल को चुनने के लिए /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": {}
      }
    }
  }
}

Custom provider

किसी भी 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 ProviderDisplay 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 कमांड चलाएँ और आपका कस्टम प्रदाता और मॉडल चयन सूची में दिखाई देंगे।

Example

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

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",
        "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 से स्वचालित रूप से प्राप्त करते हैं।

Troubleshooting

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

  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 एंडपॉइंट का उपयोग किया गया है।
कॉन्फ़िगरेशननेटवर्क