Connect your app to Clydex.

Text messages may use system, developer, user, or assistant roles. Responses accepts a text input and optional instructions. Chat accepts text messages. Always set an output cap: max_output_tokens for Responses, or exactly one of max_completion_tokens and max_tokensfor Chat. Storage must be false or omitted; Chat permits only one result.

Tools, tool results, structured output, sampling controls, explicit reasoning controls, stored history, previous responses, media, remote attachments, WebSockets, and Anthropic calls are unavailable. Unknown fields are rejected. An SDK may add defaults that are outside this profile; inspect its request configuration before use.

Set up a named Clydex connection for the Responses API. This configures authentication and the endpoint; full Codex agent sessions are currently unavailable because they need features beyond Clydex’s text profile.

1. Export CLYDEX_API_KEY using the Quickstart. Launch Codex from an environment that can read that variable, including when using the app or VS Code.
2. Merge the settings below into your user ~/.codex/config.toml. Replace the model placeholder with an ID from your Clydex key’s catalog.
3. Restart the client after changing its environment or configuration.

model_provider = "clydex"
model = "<MODEL_FROM_YOUR_KEY_CATALOG>"

[model_providers.clydex]
name = "Clydex"
base_url = "https://<YOUR_CLYDEX_DOMAIN>/v1"
env_key = "CLYDEX_API_KEY"
wire_api = "responses"
requires_openai_auth = false
supports_websockets = false
request_max_retries = 0
stream_max_retries = 0

The resulting endpoint must be /v1/responses. Requests need an explicit output cap and must omit stored history, tools, and reasoning controls. If your client cannot meet those requirements, use the direct API example below. These settings do not make an unsupported agent session compatible.

Claude Code requires the Messages API and agent tools. Clydex does not currently expose /v1/messages or those tool workflows, so there is no supported Clydex setup for its terminal or VS Code interface.

Keep Clydex keys out of incompatible connection settings. For a Clydex text request, use the API example or review the Cherry Studio settings below.

Claude Desktop’s inference connection cannot currently use Clydex. Clydex provides Responses and Chat Completions, while this integration needs the Messages API. Developer settings and MCP connections do not translate between these APIs.

Use the Clydex Quickstart for text generation. There is no Clydex Desktop launch command or token configuration to apply at this time.

Add Clydex as a custom Chat Completions connection. The following configuration is for OpenCode versions using the provider configuration schema.

1. In OpenCode, run /connect, select Other, use clydex as the connection ID, and enter your Clydex API key.
2. Merge the JSON below into your project’s opencode.json and replace the model placeholder. Keep the secret in the credential store.
3. Run /models and select the model under Clydex.

{
  "provider": {
    "clydex": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Clydex",
      "options": { "baseURL": "https://<YOUR_CLYDEX_DOMAIN>/v1" },
      "models": {
        "<MODEL_FROM_YOUR_KEY_CATALOG>": { "name": "Clydex text" }
      }
    }
  }
}

Before sending, confirm the client sends an output cap and omits tools, sampling controls, and stored history. Set context and output limits from Channels & Models. Agent execution is unavailable. If your version uses a different config schema or always adds unsupported fields, use the direct API example instead.

Grok models and Grok search features are not currently available in Clydex. This applies to Grok CLI and Grok configurations inside Claude Code, Codex, and OpenCode. Entering a Grok model name does not enable access.

To use a model from your Clydex catalog in Codex or OpenCode, follow that application’s Clydex guide and its stated limits. A Clydex key does not include a Grok subscription.

Configure a named custom endpoint using Chat Completions. Export CLYDEX_API_KEY in the environment that starts Hermes, then merge these settings into ~/.hermes/config.yaml and replace the model placeholder.

providers:
  clydex:
    name: Clydex
    api: https://<YOUR_CLYDEX_DOMAIN>/v1
    key_env: CLYDEX_API_KEY
    transport: chat_completions

model:
  provider: custom:clydex
  default: <MODEL_FROM_YOUR_KEY_CATALOG>

Run hermes model outside an active chat to select the connection. Within a chat, /model custom:clydex:<MODEL_ID> selects an already configured model. Use text only, set an output cap, and disable tools and automatic fallback. If your version always sends tools or unsupported options, it cannot use Clydex’s current text profile. Full agent workflows remain unavailable.

1. Open the application’s model-provider settings, add a connection named Clydex, and choose the OpenAI-compatible API type.
2. Set its base URL to https://<YOUR_CLYDEX_DOMAIN>/v1 and credential to your Clydex API key.
3. Refresh the model list or add an exact ID from your Clydex catalog. Select Chat Completions when your version offers a protocol choice.
4. Set an output limit within the model’s published cap. Turn off tools, web search, attachments, reasoning options, and custom sampling parameters.
5. Send a short text message, then check its completed status, tokens, and charge in Clydex request history.

The final request URL must be /v1/chat/completions, with no repeated /v1. If the client returns an unsupported-field error, remove the named option. A client version that cannot omit it is not compatible with the current profile. Image requests are unavailable.

Use the Quickstart for curl, or send a text request with the Python SDK below. Install the openai package in your Python environment, export CLYDEX_API_KEY, and replace the model placeholder. Your account must have an active model and enough available balance.

import os
import uuid
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["CLYDEX_API_KEY"],
    base_url="https://<YOUR_CLYDEX_DOMAIN>/v1",
    max_retries=0,
)

# Keep this ID if the same generation needs an explicit retry.
request_id = str(uuid.uuid4())
response = client.responses.create(
    model="<MODEL_FROM_YOUR_KEY_CATALOG>",
    input="Reply with one short word.",
    max_output_tokens=32,
    store=False,
    extra_headers={"Idempotency-Key": request_id},
)
print(response.output_text)

For a Node client, pass your key as apiKey, this URL as baseURL, and maxRetries: 0. Use the strict JSON payload from the Quickstart. Select Chat Completions only for a model that supports that protocol. SDK versions have not yet been verified against a live Clydex model.

On a timeout, inspect request history before starting a new generation. Keep the same idempotency ID for an intentional retry of the same body; Clydex reports an already accepted request without replaying its content. Use a new ID only for a new generation.

Clydex does not currently serve /v1/messages. Anthropic Python and TypeScript clients require that protocol, so changing their base URL and API key alone will not connect them to Clydex.

Use the Responses SDK example or the Chat Completions Quickstart for text requests. Messages requests are not automatically translated into either endpoint.