> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenClaw

> OpenClaw को उसके कस्टम प्रोवाइडर ऑनबोर्डिंग या उसकी कॉन्फ़िग फ़ाइल के माध्यम से FlexInference पर पॉइंट करें।

OpenClaw एक कस्टम प्रोवाइडर के माध्यम से किसी भी OpenAI-कम्पैटिबल endpoint तक पहुँचता है। ऑनबोर्डिंग आपके लिए एंट्री लिखता है, और कॉन्फ़िग फ़ाइल बाद में उसे रखती है।

OpenClaw का अपना कोई प्रति-अनुरोध डेडलाइन फ़ील्ड नहीं है, इसलिए डेडलाइन key पर जाती है। पहले एक बनाएं (देखें [agent keys](/hi/agent-keys))।

## इसे एक एजेंट के साथ सेट करें

नीचे दिए गए ब्लॉक को खोलें और इसे किसी भी कोडिंग एजेंट में कॉपी करें। प्रॉम्प्ट कभी भी आपकी API key नहीं मांगता है: एजेंट बाकी सब कॉन्फ़िगर करता है, फिर आपके लिए चलाने के लिए एक एक्सपोर्ट लाइन प्रिंट करता है।

<Accordion title="एजेंट सेटअप प्रॉम्प्ट कॉपी करें">
  ```text theme={null}
  Configure OpenClaw to send its requests to FlexInference through a custom provider. Use the OpenClaw CLI, not hand-edited JSON, so every write is schema-validated.

  You will never see or handle my API key. OpenClaw will read it from the `FLEXINFERENCE_API_KEY` environment variable through a secret reference, and I export that myself. Do not ask me for the key, do not pass it on any command line, and do not read it from my environment.

  Ask whether to use my default OpenClaw profile or a separate one. A separate profile isolates config, state, gateway port, and workspace, and is the safe way to try this. Prefix every command with `--profile flex` if I choose one.

  1. Confirm which config file is active with `openclaw config file`.

  2. Tell me to export the key first, and stop until I confirm. Print this line; do not run it and do not ask for the value:

  export FLEXINFERENCE_API_KEY=<paste your key here>

  3. Write the provider entry. It carries no credential. The model row is required, because OpenClaw refuses a third-party provider that declares no `models`; step 5 replaces it with the full catalog:

  openclaw config set models.providers.flexinference --merge --strict-json '{"baseUrl":"https://api.flexinference.com/v1","api":"openai-completions","models":[{"id":"gpt-5.6-sol","name":"GPT-5.6 Sol","compat":{"supportsUsageInStreaming":true}}]}'

  4. Declare an environment secrets provider, then point the provider's apiKey at it. Both commands pass only the VARIABLE NAME, never the value:

  openclaw config set secrets.providers.default \
    --provider-source env --provider-allowlist FLEXINFERENCE_API_KEY

  openclaw config set models.providers.flexinference.apiKey \
    --ref-provider default --ref-source env --ref-id FLEXINFERENCE_API_KEY

  5. Fill the model list from the live FlexInference catalog rather than by hand:

  curl -s https://api.flexinference.com/v1/models \
    -H "Authorization: Bearer $FLEXINFERENCE_API_KEY" \
  | jq '{models:{providers:{flexinference:{models:
      [.data[] | {id, name: .id, compat: {supportsUsageInStreaming: true}}]}}}}' \
  | openclaw config patch --stdin

  Run every write with `--dry-run` first and show me the diff before applying it.

  6. Verify with `openclaw models list --provider flexinference`, then run `openclaw security audit`.

  Rules that matter, do not deviate:
  - Never pass my key as an argument to an `openclaw` command, and never write it into a config file. `openclaw onboard --custom-api-key` does both, which is why step 4 uses a reference instead.
  - Step 5 is the one place the key expands, into curl's `-H` argument, where a same-user process can read it. That is a deliberate trade for a single catalog read. Do not extend it to any other command.
  - The provider id must be `flexinference` in every command. If an earlier setup derived `custom-api-flexinference-com` from the host, tell me, and use that id consistently instead of creating a second provider.
  - `api` must be `openai-completions`. That is the only adapter FlexInference's Chat Completions surface works with here.
  - The base URL must end in `/v1`.
  - You MUST list models explicitly. OpenClaw only lets its own built-in provider ids omit `models`, and it will never call `GET /v1/models` for a provider defined in config. Model discovery is a plugin capability and does not apply here.
  - Every model row needs `compat: { supportsUsageInStreaming: true }`. OpenClaw makes streaming usage opt-in for third-party endpoints, and without it every streamed turn reports zero tokens and no cost.
  - Leave `"mode": "merge"` alone so my existing providers survive.
  - Step 4 resolves the reference at write time, so it fails if I have not exported the variable yet. That failure is expected, not a reason to fall back to a literal key.
  - FlexInference's catalog publishes no context window or token ceiling, so generated rows carry neither. Do not invent values; leave them out unless I give you numbers.

  Report what you changed and which config file you wrote.
  ```
</Accordion>

## एक कस्टम प्रोवाइडर को ऑनबोर्ड करें

1. गाइडेड सेटअप शुरू करें।

```bash theme={null}
openclaw onboard
```

2. जब यह auth के बारे में पूछे तो कस्टम प्रोवाइडर विकल्प चुनें। वह `custom-api-key` है।
3. `/v1` सफ़िक्स सहित राउटर को base URL के रूप में दर्ज करें।

```text theme={null}
https://api.flexinference.com/v1
```

4. अपनी agent key पेस्ट करें।
5. कम्पैटिबिलिटी मोड को `openai` पर छोड़ दें। यह हमारा Chat Completions surface है।
6. एक model id दर्ज करें जिसे हम चलाते हैं, जैसे `gpt-5.6-sol`।

प्रॉम्प्ट कभी भी आपकी key को कमांड लाइन पर नहीं रखता है, यही कारण है कि यहां दिखाया गया पथ है।

`openclaw onboard --non-interactive` भी मौजूद है, लेकिन इसका `custom-api-key` auth मोड `--custom-api-key` से क्रेडेंशियल पढ़ता है, इसलिए secret आपकी शेल हिस्ट्री और प्रोसेस आर्गुमेंट्स में समाप्त हो जाता है। इसके बजाय config commands और एक secret reference के साथ सेटअप को स्क्रिप्ट करें, जो एक्सपोजर के बिना समान परिणाम है।

आप जो भी रास्ता अपनाएं, प्रोवाइडर id खुद सेट करें:

```bash theme={null}
openclaw config set models.providers.flexinference --merge --strict-json \
  '{"baseUrl":"https://api.flexinference.com/v1","api":"openai-completions","models":[{"id":"gpt-5.6-sol","name":"GPT-5.6 Sol","compat":{"supportsUsageInStreaming":true}}]}'
```

अपने आप में, OpenClaw host से id प्राप्त करता है और `custom-api-flexinference-com` के साथ समाप्त होता है, और इस पृष्ठ पर हर बाद के कमांड को उस नाम की आवश्यकता होगी।

लिखने में एक मॉडल रो शामिल है क्योंकि उसे करना है। OpenClaw एक थर्ड-पार्टी प्रोवाइडर को अस्वीकार करता है जो कोई `models` घोषित नहीं करता है, इसलिए `baseUrl`-केवल लिखने से स्कीमा सत्यापन विफल हो जाता है। अगले सेक्शन में पूरी रो को बदलें।

कम्पैटिबिलिटी मोड `api` पर मैप करता है। `openai` `openai-completions` लिखता है, जो वह है जिसके साथ हमारा Chat Completions endpoint काम करता है। अन्य विकल्प `openai-responses` और `anthropic` हैं।

## कॉन्फ़िग फ़ाइल

ऑनबोर्डिंग `~/.openclaw/openclaw.json` में `models.providers` के तहत लिखता है। `openclaw config file` के साथ OpenClaw जिस पथ का उपयोग कर रहा है उसे प्रिंट करें।

```json theme={null}
{
  "models": {
    "mode": "merge",
    "providers": {
      "flexinference": {
        "baseUrl": "https://api.flexinference.com/v1",
        "api": "openai-completions",
        "apiKey": {
          "source": "env",
          "provider": "default",
          "id": "FLEXINFERENCE_API_KEY"
        },
        "models": [
          {
            "id": "gpt-5.6-sol",
            "name": "GPT-5.6 Sol",
            "contextWindow": 400000,
            "maxTokens": 128000,
            "input": ["text", "image"],
            "compat": { "supportsUsageInStreaming": true }
          }
        ]
      }
    }
  }
}
```

`"mode": "merge"` आपके बिल्ट-इन प्रोवाइडर को रखता है और उनके बगल में इसे जोड़ता है।

`api` `openai-completions` होना चाहिए। ऑनबोर्डिंग `openai` कम्पैटिबिलिटी मोड ठीक यही लिखता है।

`apiKey` एक सादा स्ट्रिंग भी लेता है, जो ऑनबोर्डिंग लिखता है। यहां दिखाया गया reference secret को फ़ाइल से बाहर रखता है। keep the key out of the config file देखें।

**अपने मॉडल खुद सूचीबद्ध करें।** केवल OpenClaw के बिल्ट-इन प्रोवाइडर id ही `models` को छोड़ सकते हैं। एक थर्ड-पार्टी id को `baseUrl` और `models` दोनों घोषित करना होगा, इसलिए पिकर में आप जो भी मॉडल चाहते हैं उसके लिए एक रो जोड़ें।

**`compat.supportsUsageInStreaming` सेट करें।** OpenClaw एक थर्ड-पार्टी endpoint के लिए स्ट्रीमिंग उपयोग को ऑप्ट-इन बनाता है, क्योंकि कुछ सर्वर इसे अस्वीकार करते हैं। इस फ़्लैग के बिना हमें उपयोग फ्रेम के लिए अनुरोध कभी नहीं मिलता है, इसलिए हर स्ट्रीम किया गया टर्न शून्य टोकन और कोई लागत नहीं बताता है।

## हमारे कैटलॉग से मॉडल सूची भरें

OpenClaw आपके द्वारा कॉन्फ़िग में परिभाषित प्रोवाइडर के लिए `GET /v1/models` को कॉल नहीं करेगा। मॉडल डिस्कवरी एक प्लगइन क्षमता है, और जिन बंडल प्लगइन्स में यह है वे ही इसका उपयोग करते हैं। एक कॉन्फ़िग-परिभाषित प्रोवाइडर अपनी `models` ऐरे और कुछ नहीं पढ़ता है।

इसके बजाय हमारे कैटलॉग से उस ऐरे को जनरेट करें, और इसे एक कमांड में लिखें।

```bash theme={null}
export FLEXINFERENCE_API_KEY=<your agent key>

curl -s https://api.flexinference.com/v1/models \
  -H "Authorization: Bearer $FLEXINFERENCE_API_KEY" \
| jq '{models:{providers:{flexinference:{models:
    [.data[] | {id, name: .id, compat: {supportsUsageInStreaming: true}}]}}}}' \
| openclaw config patch --stdin
```

`config patch` ऑब्जेक्ट्स को मर्ज करता है और ऐरे को बदलता है, इसलिए यह मॉडल सूची को स्वैप करता है और `baseUrl` और `apiKey` को अछूता छोड़ देता है। पहले लिखने को देखने के लिए `--dry-run` जोड़ें।

केवल उन मॉडलों को रखें जो कैटलॉग के अपने फ़्लैग पर फ़िल्टर करके सस्ते टियर को रेस करते हैं।

```bash theme={null}
jq '[.data[] | select(.flexinference.flex_race) | {id, name: .id}]'
```

हमारा कैटलॉग कोई context window और कोई token ceiling प्रकाशित नहीं करता है, इसलिए इस तरह से बनाई गई पंक्तियों में से कोई भी नहीं होता है। `contextWindow` और `maxTokens` खुद जोड़ें जहां OpenClaw के डिफ़ॉल्ट मॉडल के अनुरूप नहीं होते हैं।

जब भी हमारा कैटलॉग बदलता है तो कमांड को फिर से चलाएं। परिणाम जांचें:

```bash theme={null}
openclaw models list --provider flexinference
```

## ग्लोबल कॉन्फ़िग और प्रोफाइल

OpenClaw प्रति प्रोफाइल एक कॉन्फ़िग रखता है, प्रति फ़ोल्डर एक नहीं। वर्किंग डायरेक्टरी कभी नहीं बदलती कि वह कौन सी फ़ाइल पढ़ती है।

| स्कोप    | कॉन्फ़िग पथ                 | इसे कैसे चुनें         |
| -------- | --------------------------- | ---------------------- |
| डिफ़ॉल्ट | `~/.openclaw/openclaw.json` | डिफ़ॉल्ट               |
| नामित    | `~/.openclaw-<name>/`       | `--profile <name>`     |
| देव      | `~/.openclaw-dev/`          | `--dev`                |
| स्पष्ट   | कोई भी पथ                   | `OPENCLAW_CONFIG_PATH` |

अपने सामान्य सेटअप को छुए बिना FlexInference को आज़माने के लिए एक नामित प्रोफाइल का उपयोग करें।

```bash theme={null}
openclaw --profile flex onboard
```

एक प्रोफाइल कॉन्फ़िग के साथ-साथ स्टेट को भी अलग करता है, इसलिए इसका gateway port और workspace भी अलग होते हैं।

## key को कॉन्फ़िग फ़ाइल से बाहर रखें

ऑनबोर्डिंग key को `openclaw.json` में सादे टेक्स्ट में लिखता है। इसके बजाय `apiKey` को एक secret reference पर सेट करें, और कॉन्फ़िग वेरिएबल के मान के बजाय उसका नाम संग्रहीत करता है।

1. उस शेल में key एक्सपोर्ट करें जिससे आप इन कमांड को चलाएंगे।

```bash theme={null}
export FLEXINFERENCE_API_KEY=<your agent key>
```

2. एक environment secrets प्रोवाइडर घोषित करें और उस एक वेरिएबल को अनुमति दें।

```bash theme={null}
openclaw config set secrets.providers.default \
  --provider-source env --provider-allowlist FLEXINFERENCE_API_KEY
```

3. प्रोवाइडर के `apiKey` को उस पर पॉइंट करें।

```bash theme={null}
openclaw config set models.providers.flexinference.apiKey \
  --ref-provider default --ref-source env --ref-id FLEXINFERENCE_API_KEY
```

कॉन्फ़िग तब `{"source": "env", "provider": "default", "id": "FLEXINFERENCE_API_KEY"}` रखता है और कोई secret नहीं। key कभी भी कमांड लाइन तक नहीं पहुंचती है, क्योंकि स्टेप 3 केवल वेरिएबल का नाम पास करता है।

जब आप स्टेप 3 चलाते हैं तो OpenClaw reference को हल करता है, इसलिए पहले वेरिएबल को एक्सपोर्ट करें। एक गुम या खाली वेरिएबल `SecretRefResolutionError` के साथ लिखने को विफल कर देता है बजाय कुछ टूटा हुआ संग्रहीत करने के। लिखने के बिना जांचने के लिए `--dry-run` जोड़ें।

बिल्ट-इन ऑडिट के साथ क्या उजागर हुआ है उसकी जांच करें।

```bash theme={null}
openclaw security audit
```

## पुष्टि करें कि key लागू हो गई है

हर प्रतिक्रिया `x-flexinference-defaults-applied` के साथ आती है। OpenClaw प्रतिक्रिया हेडर नहीं दिखाता है, इसलिए इसके बजाय **Logs** के तहत डैशबोर्ड में अनुरोध पढ़ें।

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

**मॉडल पिकर छोटा है, या कोई मॉडल गायब है।** एक कॉन्फ़िग-परिभाषित प्रोवाइडर कभी भी `GET /v1/models` को कॉल नहीं करता है, इसलिए यह केवल आपके द्वारा लिखी गई पंक्तियों को दिखाता है। हमारे कैटलॉग से सूची को फिर से जनरेट करें।

**टर्न शून्य टोकन और कोई लागत नहीं बताते हैं।** OpenClaw ने हमसे स्ट्रीमिंग उपयोग के लिए नहीं पूछा, इसलिए हमने कोई उपयोग फ्रेम नहीं भेजा। प्रत्येक मॉडल रो पर `compat.supportsUsageInStreaming` को `true` पर सेट करें।

**एक मॉडल id अस्वीकृत है।** आपके द्वारा हाथ से लिखी गई पंक्तियाँ हमारे द्वारा चलाए जाने वाले से भिन्न हो सकती हैं, क्योंकि `id` ठीक वैसे ही बाहर जाता है जैसे लिखा गया था। id को संपादित करने के बजाय हमारे कैटलॉग से सूची को फिर से जनरेट करें।

**कॉन्फ़िग संपादन प्रभावी नहीं होते हैं।** gateway पुरानी कॉन्फ़िग रखता है। इसे पुनरारंभ करें, और पुष्टि करें कि आपने उस फ़ाइल को संपादित किया है जिसे `openclaw config file` प्रिंट करता है।

हमारे द्वारा लौटाए गए हर अस्वीकृति के लिए [errors](/hi/errors) देखें, और उन लोगों के लिए [agent keys](/hi/agent-keys) देखें जो OpenClaw के लिए विशिष्ट नहीं हैं।