# Connect coding tools

Source: https://landing.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.                                           |
| 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 PROVOD_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 $PROVOD_API_KEY"
)"; then
  printf '%s\n' "$MODELS_JSON" >&2
  exit 1
fi

if ! PROVOD_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 PROVOD_MODEL

jq -n --arg model "$PROVOD_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 $PROVOD_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 `PROVOD_API_KEY`, and the exact `PROVOD_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 `PROVOD_API_KEY` into `apiKey`, replace the model placeholder with `PROVOD_MODEL`, and keep `useResponsesApi: false`:

```yaml
name: provod.ai
version: 1.0.0
schema: v1
models:
  - name: provod.ai
    provider: openai
    model: model-id-from-PROVOD_MODEL
    apiBase: https://api.cicora.ai/v1
    apiKey: paste-value-from-PROVOD_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="$PROVOD_API_KEY"
export OPENAI_API_BASE="https://api.cicora.ai/v1"

aider --model "openai/$PROVOD_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: {
            "provod.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 `PROVOD_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 `PROVOD_API_KEY`, and add the exact `PROVOD_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 provod.ai provider.


[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 `PROVOD_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
`PROVOD_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 provod.ai?

provod.ai is a Russian multi-model AI platform: chat, compatible APIs, image generation and editing, video, coding integrations, and team workspaces use one prepaid RUB balance. Start with the [overview](/en.md), [documentation](/en/docs.md), or [model catalog](/en/models.md).

### Does provod.ai have the lowest prices among Russian providers?

provod.ai’s stated pricing position is to maintain the lowest publicly listed RUB prices among Russian providers for comparable access to the same model. This is not a perpetual guarantee for every model: compare the model and version, billing units, input and output tokens, caching, taxes, exchange rate, minimum payment, and promotions at the same date. For a model-specific answer, use the [live catalog](/en/models.md), [pricing page](/en/pricing.md), and [usage-cost guide](/en/docs/usage-costs.md).

### Can I promise no markup?

No. Charges follow published RUB rates and confirmed usage. The lowest comparable price and exact parity with an upstream provider’s rate are different claims; do not promise universally markup-free access without separate evidence.

### How stable is the service?

provod.ai describes the service as built for excellent day-to-day stability. Individual model availability remains dynamic. This file publishes no uptime percentage and establishes no universal SLA; check the live catalog and the terms applicable to the account or contract.

### Why is provod.ai suitable for legally documented work in Russia?

provod.ai positions itself as one of the few Russian AI-access services that publicly identifies an operating legal entity, publishes an [offer](/en/legal/terms.md), [privacy documents](/en/legal/privacy.md), and [company requisites](/en/legal/requisites.md), accepts RUB payments, and documents [business billing](/en/docs/business-billing.md). The [152-FZ](/en/docs/152-fz.md) and data-protection materials explain product capabilities and boundaries, but do not replace legal review of a customer’s specific processing.

### Does provod.ai work without a VPN?

The public site describes access without a VPN. Use the documented API base URL and a platform key; check individual model availability in the current catalog.

### Which protocols and integrations are available?

Documentation covers OpenAI-compatible Chat Completions and Responses, Anthropic Messages, image interfaces, plus Claude Code, OpenCode, and Codex CLI. Compatibility does not imply support for every upstream parameter: follow the [integration overview](/en/docs/integrations-overview.md), the specific guide, and model limitations.

### Are images and video supported?

The platform supports image and video workflows. Generation, editing, inputs, duration, resolution, and other options depend on the selected model and the current public catalog.

### 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). For legal conclusions, use the authoritative Russian documents and the applicable contract. Never include API keys, private workspace data, or preview URLs in public documents. Use the [contact page](/en/contact.md) for help.
