Skip to content
ATLAS
 Docs
On this page

Connect your IDE#

Send chat and agent requests from GitHub Copilot Chat, JetBrains AI Assistant or Continue through the ATLAS gateway. ATLAS audits and budgets the requests, and limits them to the models your space or project offers. You don't need Admin rights.

Supported tools#

Tool Where
GitHub Copilot Chat VS Code
GitHub Copilot Chat and Copilot CLI JetBrains IDEs, terminal
JetBrains AI Assistant JetBrains IDEs
Continue VS Code, JetBrains IDEs

If a tool isn't listed, see What does not work.

Before you begin#

  • You need an ATLAS API key with an acting context (a space or project). See Create and manage your API keys.
  • You need at least one model in that acting context. For agent mode, choose a model that supports tool calling and is not a reasoning model. Some reasoning models reject tool calls on the Chat Completions API.
  • You need your ATLAS address. Replace https://<atlas-host> with it throughout.
  • Wherever a snippet shows <your-atlas-key> or <model-id>, replace it with your ATLAS API key or a model id such as openai/gpt-4.1. Keep the rest of the line as it is.
  • Check the key and a model from a terminal first, using the connection settings and test requests.

Every set-up on this page uses the base URL https://<atlas-host>/gateway/openai/v1 and your ATLAS API key.

Use model ids in the form provider-slug/model-slug, exactly as the /models request lists them. Where a tool offers a choice, choose the Chat Completions API type.

Use ATLAS models in GitHub Copilot Chat in VS Code#

VS Code connects ATLAS as a Custom Endpoint provider. Copilot's chat client is the only supported entry point. The models come from ATLAS, not from your Copilot licence.

  1. In the Chat view, open the model picker and select Manage Language Models, or run Chat: Manage Language Models from the Command Palette.

  2. Select Add Models, then Custom Endpoint.

  3. Enter a group name such as ATLAS and paste your ATLAS API key when prompted.

  4. Select the API type Chat Completions.

  5. In the chatLanguageModels.json file that opens, describe your ATLAS models and save:

    json
    [
  {
    "name": "ATLAS",
    "vendor": "customendpoint",
    "apiKey": "${input:atlasApiKey}",
    "apiType": "chat-completions",
    "models": [
      {
        "id": "<model-id>",
        "name": "ATLAS <model-id>",
        "url": "https://<atlas-host>/gateway/openai/v1/chat/completions",
        "toolCalling": true,
        "vision": false,
        "maxInputTokens": 128000,
        "maxOutputTokens": 4096
      }
    ]
  }
]

    Use the full chat URL including /chat/completions. Set toolCalling to true only for models that support it. VS Code hides models without it in agent mode.

  6. Select the ATLAS model in the model picker and send a message in Ask mode, then switch to Agent mode.

If the model doesn't appear, restart VS Code. In Copilot Business or Enterprise, a GitHub organisation owner must turn on the Bring Your Own Language Model Key in VS Code policy on GitHub.com.

Inline suggestions, next edit suggestions, semantic search and anything based on embeddings always use the GitHub Copilot service and never reach ATLAS. Background tasks such as chat titles and commit messages use a Copilot model. To use an ATLAS model instead, point the chat.utilityModel and chat.utilitySmallModel settings at it.

Vendor documentation: VS Code, AI language models.

Use ATLAS models in GitHub Copilot Chat in JetBrains IDEs#

The GitHub Copilot plugin supports a custom OpenAI-compatible provider. You need a recent plugin version and a Copilot licence.

  1. Open Copilot Chat and, in the model picker, select Manage Models.
  2. Add a custom provider that is OpenAI-compatible.
  3. Enter the Base URL https://<atlas-host>/gateway/openai/v1 and your ATLAS API key.
  4. Add the model ids exactly as /models lists them, and set the maximum input and output tokens.
  5. Turn on the models and pick one in the chat model picker.
  6. Send a message in Ask mode, then switch to Agent mode.

Field names may differ between plugin versions. Use a model that works on Chat Completions.

To use Copilot CLI with ATLAS, set these variables in a terminal and run copilot. The model must support tool calling and streaming. Replace <your-atlas-key> and <model-id> as described in Before you begin.

bash
export COPILOT_PROVIDER_BASE_URL=https://<atlas-host>/gateway/openai/v1
export COPILOT_PROVIDER_TYPE=openai
export COPILOT_PROVIDER_API_KEY=<your-atlas-key>
export COPILOT_MODEL=<model-id>

As in VS Code, inline suggestions, next edit suggestions and embedding-based features stay on the GitHub Copilot service.

Vendor documentation: GitHub Copilot plugin, Bring your own key and BYOK in Copilot CLI.

Use ATLAS models in JetBrains AI Assistant#

  1. Open Settings | Tools | AI Assistant | Providers & API keys.
  2. Under Third-party AI providers, select OpenAI-compatible.
  3. Enter the URL https://<atlas-host>/gateway/openai/v1 and your ATLAS API key as the API Key.
  4. Turn on Tool calling if your model supports it.
  5. Select Test Connection, then Apply.
  6. In Models Assignment, assign ATLAS models such as openai/gpt-4.1 to Core features and Instant helpers.
  7. Open AI Chat, choose the ATLAS model and send a message. Then try agent mode.

Third-party chat providers don't power code completion or next edit suggestions. Completion through a custom provider needs a fill-in-the-middle endpoint, which ATLAS doesn't offer.

Vendor documentation: JetBrains, Use custom models.

Use ATLAS models in Continue#

Continue runs in VS Code and JetBrains IDEs.

  1. Install the Continue extension or plugin.

  2. Open the Continue config.yaml from the Continue panel settings.

  3. Add an ATLAS model:

    yaml
    name: ATLAS
version: 1.0.0
schema: v1
models:
  - name: ATLAS <model-id>
    provider: openai
    model: <model-id>
    apiBase: https://<atlas-host>/gateway/openai/v1
    apiKey: <your-atlas-key>
    useResponsesApi: false
    roles:
      - chat
      - edit
      - apply
    capabilities:
      - tool_use

    useResponsesApi: false keeps Continue on Chat Completions. Agent mode needs tool_use, so keep it only for models that support tool calling.

  4. Select the ATLAS model in the Continue panel, send a message in Chat, then switch to Agent.

Don't add the autocomplete role. It needs a fill-in-the-middle endpoint, which ATLAS doesn't offer. The embed role can work if an embedding-capable model (not Anthropic) is configured in ATLAS.

Vendor documentation: Continue, OpenAI provider.

Result: the ATLAS models appear in your IDE's model picker, and each chat or agent request shows in My usage under your key's acting context.

What ATLAS sees#

ATLAS audits and budgets only the requests sent to your ATLAS models. It can't see anything a tool keeps on its vendor's service. For more information, see Gateway concepts.

What does not work#

  • Claude Code works through a separate endpoint. See Connect Claude Code and opencode.
  • OpenAI Codex CLI isn't covered here. It needs the Responses API rather than Chat Completions.
  • Gemini CLI needs Google's native Gemini API, which the gateway doesn't offer.
  • Autocomplete in any tool needs a legacy completions endpoint, which the gateway doesn't offer.
  • GitHub Copilot's own models as an ATLAS provider aren't possible. Ask an Admin to add models of the same families through an OpenAI, Azure OpenAI or Anthropic provider instead.

Troubleshooting#

Errors from your IDE are gateway errors. See the troubleshooting table. Two points are specific to IDEs:

  • If the tool lists no models, add the model id manually after you confirm it with the /models request.
  • If agent mode fails with a provider 400 about function tools, switch to a model that supports tool calling and is not a reasoning model.