# Connect coding tools

Source: https://cicora.ai/en/docs/integrations-overview

## Check compatibility

In these tools, a **provider** is a saved connection that supplies an API URL, key, and model settings.

| Tool         | Interface or configuration path              | Status and key caveat                                                                            |
| ------------ | -------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| Cline        | **OpenAI Compatible** in VS Code settings    | Compatible; enter an exact catalog ID manually.                                                  |
| Roo Code     | **Settings → Providers → OpenAI Compatible** | Compatible; remove a stale built-in model selection.                                             |
| Kilo Code    | **Providers → OpenAI Compatible**            | Compatible; select the custom provider explicitly.                                               |
| Continue     | Local `config.yaml`, provider `openai`       | Use the protocol required by the selected client; Chat Completions remains the documented setup. |
| Aider        | Shell environment                            | Compatible; invoke the catalog ID as `openai/<catalog-id>`.                                      |
| Zed          | `settings.json` and the provider keychain    | Compatible; generate the model ID and limit from the live catalog.                               |
| Cursor       | **Override OpenAI Base URL**                 | Version-dependent; proceed only when this field is available.                                    |
| Claude Code  | [Dedicated guide](/en/docs/claude-code)      | Compatible through Anthropic Messages; its base URL omits `/v1`.                                 |
| OpenCode     | [Dedicated guide](/en/docs/opencode)         | Compatible through the installer or a manual provider.                                           |
| Hermes Agent | [Dedicated guide](/en/docs/hermes)           | Compatible through a custom endpoint and Chat Completions.                                       |
| Codex CLI    | [Support status](/en/docs/codex-cli)         | Responses endpoint is published; end-to-end Codex CLI compatibility is not yet documented.       |

## Select and verify a model first

OpenAI-compatible tools on this page share these values:

| Value    | Setting                                          |
| -------- | ------------------------------------------------ |
| Base URL | `https://api.cicora.ai/v1`                       |
| API key  | A key created in the cabinet                     |
| Model ID | An available exact `id` from the current catalog |

Run this from a shell with `curl` and `jq`. It requires an available text model with both `tools` and the `max_tokens` used by the verification request, and excludes image endpoint entries:

```bash
set -euo pipefail

export CICORA_API_KEY="sk_..."

if ! MODELS_JSON="$(
  curl --fail-with-body --silent --show-error "https://api.cicora.ai/v1/models?output_modalities=text&supported_parameters=tools,max_tokens" \
    -H "Authorization: Bearer $CICORA_API_KEY"
)"; then
  printf '%s\n' "$MODELS_JSON" >&2
  exit 1
fi

if ! CICORA_MODEL="$(
  jq -er '
    first(
      .data[]
      | select(
          .available == true
          and ((.architecture.output_modalities // []) | index("text"))
          and ((.supported_parameters // []) | index("tools"))
          and ((.supported_parameters // []) | index("max_tokens"))
          and ((.supported_endpoint_types // []) | all(. != "image-generation" and . != "image-edit"))
        )
      | .id
    )
  ' <<<"$MODELS_JSON"
)"; then
  printf 'No available tool-capable text model found in /v1/models.\n' >&2
  exit 1
fi

export CICORA_MODEL

jq -n --arg model "$CICORA_MODEL" '{
  model: $model,
  messages: [{role: "user", content: "Reply with ok"}],
  max_tokens: 64
}' | curl --fail-with-body --silent --show-error https://api.cicora.ai/v1/chat/completions \
  -H "Authorization: Bearer $CICORA_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @-
```

If this fails, fix the key, catalog selection, or request before changing tool settings. If it succeeds, compare the tool's final URL, protocol, exact model ID, and key source with these verified values.

**Protect the API key**


Keep the key in an environment variable, operating-system keychain, protected
local tool configuration, or trusted backend. Never put it in browser code or
commit it to a repository. Revoke it in the cabinet if a local configuration
is exposed.


## Configure Chat Completions tools

### Cline, Roo Code, and Kilo Code

Open the interface named in the matrix and enter `https://api.cicora.ai/v1`, the value exported as `CICORA_API_KEY`, and the exact `CICORA_MODEL` selected above. Start one short task before enabling tools or long agent work. If the direct request succeeds but an extension fails, reselect the custom provider and remove any stale built-in model override.

### Continue

Add an OpenAI model entry to Continue's protected local configuration. Paste the current value of `CICORA_API_KEY` into `apiKey`, replace the model placeholder with `CICORA_MODEL`, and keep `useResponsesApi: false`:

```yaml
name: cicora.ai
version: 1.0.0
schema: v1
models:
  - name: cicora.ai
    provider: openai
    model: model-id-from-CICORA_MODEL
    apiBase: https://api.cicora.ai/v1
    apiKey: paste-value-from-CICORA_API_KEY
    useResponsesApi: false
    roles:
      - chat
      - edit
      - apply
```

Select the entry and confirm that the client calls `/v1/chat/completions`, not `/v1/responses`.

### Aider

After running the model-selection flow above, set Aider's OpenAI-compatible variables and prefix the exact catalog ID with `openai/`:

```bash
export OPENAI_API_KEY="$CICORA_API_KEY"
export OPENAI_API_BASE="https://api.cicora.ai/v1"

aider --model "openai/$CICORA_MODEL"
```

Check Aider's model banner before allowing file changes. If it differs, compare the environment visible to Aider with the shell where the direct request succeeded.

### Zed

Use the `MODELS_JSON` captured by the selection flow to generate a complete `language_models` object from a live available tool-capable text model and its current `context_length`. The generated capability tells Zed to send the model's published `max_tokens` parameter instead of Zed's default `max_completion_tokens`:

```bash
if ! ZED_SETTINGS="$(
  jq -er '
    first(
      .data[]
      | select(
          .available == true
          and ((.architecture.output_modalities // []) | index("text"))
          and ((.supported_parameters // []) | index("tools"))
          and (.context_length | type == "number" and . > 0)
          and ((.supported_endpoint_types // []) | all(. != "image-generation" and . != "image-edit"))
        )
    ) as $model
    | {
        language_models: {
          openai_compatible: {
            "cicora.ai": {
              api_url: "https://api.cicora.ai/v1",
              available_models: [
                {
                  name: $model.id,
                  display_name: ($model.name // $model.id),
                  max_tokens: $model.context_length,
                  capabilities: {
                    tools: true,
                    images: false,
                    parallel_tool_calls: false,
                    prompt_cache_key: false,
                    chat_completions: true,
                    interleaved_reasoning: false,
                    max_tokens_parameter: true
                  }
                }
              ]
            }
          }
        }
      }
  ' <<<"$MODELS_JSON"
)"; then
  printf 'No available Zed-compatible model found in /v1/models.\n' >&2
  exit 1
fi

printf '%s\n' "$ZED_SETTINGS"
```

Merge the printed object into `settings.json`. Enter the value of `CICORA_API_KEY` through Zed's provider settings so the operating-system keychain stores it; do not put the key in `settings.json`. Then select the custom model and send one short prompt.

### Cursor

Proceed only if your Cursor version exposes **Override OpenAI Base URL**. Set it to `https://api.cicora.ai/v1`, enter the value of `CICORA_API_KEY`, and add the exact `CICORA_MODEL`. Confirm from Cursor's available diagnostics that the request uses the override. If the field is absent or Cursor sends another protocol, do not send the key to an unverified path.

## Dedicated guides


[Claude Code](/en/docs/claude-code)


Configure the Anthropic Messages endpoint.


[OpenCode](/en/docs/opencode)


Install or manually add the cicora.ai provider.


[Hermes Agent](/en/docs/hermes)


Configure a custom provider through Chat Completions.


[Codex CLI](/en/docs/codex-cli)


Read the current compatibility boundary.



Create and rotate keys as described in [API authentication](/en/docs/authentication). Refresh current model IDs, limits, and supported options through the [model catalog](/en/docs/models).

A **public error code** is the client-facing `error.code` returned by the API. Record it with the HTTP status, tool version, final endpoint, exact model ID, time, and masked key prefix; do not include the complete key.

## Troubleshooting


**The direct API verification fails**


Stop editing tool settings. Confirm `CICORA_API_KEY` is exported, then rerun
the catalog selection and minimal Chat Completions request until both
succeed.


**The direct request works but the tool fails**


Compare the tool's base URL, protocol, exact model ID, and key source with
the verified values. Remove stale custom connections or environment
variables, then retry one small request.


**The tool's model selector does not show the catalog**


A built-in selector may not discover third-party catalogs. Enter the exact
`CICORA_MODEL` manually where the tool supports custom models.


**The tool sends a request to /v1/responses**


The endpoint is published. Compare its request with [Responses and
Conversations](/en/docs/responses): hosted tools and undocumented fields are
rejected. If the tool cannot use the portable subset, configure its
documented Chat Completions integration or use Claude Code with Messages.


**A key may have been saved or sent unsafely**


Revoke it in the cabinet, create a replacement, and store the new value only
in a protected local or server-side secret store. Never send the complete
key in diagnostics.

## FAQ

### What is cicora.ai?

cicora.ai is a multi-model AI workspace and compatible API for chat, text, images, video, coding tools, and teams. Start with the [overview](/en.md), [documentation](/en/docs.md), or [model catalog](/en/models.md).

### How is usage billed?

Confirmed usage is charged in USD from the active workspace's prepaid balance. Use the live catalog for current model prices and the [usage guide](/en/docs/usage-costs.md) for settlement details.

### Which protocols and integrations are available?

Documentation covers OpenAI-compatible Chat Completions and Responses, Anthropic Messages, image interfaces, Claude Code, OpenCode, and Codex CLI. Compatibility does not imply support for every upstream parameter.

### Which sources are authoritative and current?

For model IDs, availability, capabilities, limits, and prices, use the [live catalog](/en/models.md). For API behavior, use the matching [documentation page](/en/docs.md). Never include API keys, private workspace data, or preview URLs in public documents.