Connect DEVUP AI to VS Code-No Extension Required

What Changed in VS Code?

The Custom Endpoint provider became available in the stable version of VS Code with version 1.122. It supports three API formats:

• Chat Completions
• Responses
• Messages

This guide uses the Chat Completions format exposed by DEVUP AI. VS Code's Bring Your Own Key experience can power chat and tools without requiring a bundled AI subscription. However, this does not automatically replace every AI capability inside the editor. We will cover those boundaries later.

You can verify the current behavior in the official VS Code language-model documentation and the VS Code 1.122 release notes.

The native Language Models editor in VS Code. Source: Visual Studio Code documentation.

What You Will Configure

By the end of this guide, you will have:

• A DEVUP AI API key stored through VS Code's model configuration flow.
• A Custom Endpoint group named DEVUP AI.
• A tool-capable model available in the VS Code model picker.
• Streaming chat responses inside the editor.
• A safe test workflow for validating workspace tools.

The only public endpoint required for this integration is: https://api.devupai.com/v1/chat/completions. No internal platform configuration is required.

Prerequisites

Before starting, prepare the following:

• VS Code 1.122 or newer
• A DEVUP AI account
• An active DEVUP AI API key
• The exact identifier of a model from the DEVUP AI catalog
• The model's context and output limits
• A small test repository that contains no sensitive data

You can obtain an API key from the DEVUP AI dashboard and choose a model from the DEVUP AI model catalog. For agent workflows, choose a model that explicitly supports tool calling.

Step 1: Update VS Code

Confirm that you are running VS Code 1.122 or newer.

• On Windows and Linux: Help → Check for Updates
• On macOS: Code → Check for Updates

Restart VS Code after the update. If Custom Endpoint does not appear later in the setup, checking the installed version should be your first troubleshooting step.

Step 2: Create a DEVUP AI API Key

Open the API Keys dashboard and create a dedicated key for your VS Code environment. A dedicated key is preferable because it can be rotated or revoked independently.

Security rules:

• Never publish the key in screenshots.
• Never place it inside a Git repository.
• Never paste it into source code.
• Never include it in a tutorial, issue report, or screen recording.

VS Code prompts for the key during the configuration flow. Keep the generated secret reference intact instead of replacing it with the raw value.

Step 3: Open the Language Models Editor

Open the VS Code Command Palette:

• Ctrl + Shift + P
• On macOS: Cmd + Shift + P

Run: Chat: Manage Language Models. You can also open the Chat view, select the current model, and choose Manage Language Models.

Step 4: Add a Custom Endpoint

Inside the Language Models editor:

1. Select Add Models.
2. Choose Custom Endpoint.
3. Enter DEVUP AI as the group name.
4. Enter a clear display name.
5. Provide your DEVUP AI API key when prompted.
6. Select Chat Completions as the API type.

The provider picker used to add a Custom Endpoint. Source: Visual Studio Code documentation.

VS Code will then open chatLanguageModels.json. The setup wizard creates the provider-level configuration and a secure reference to your API key. Do not replace that reference with your raw key.

Step 5: Add a DEVUP AI Model

Inside the Custom Endpoint group's models array, add a model entry using the template below. The placeholders are intentionally not valid final values. Replace every value wrapped in <...> with information from the selected model's DEVUP AI catalog page before saving.

{
  "id": "<EXACT_MODEL_ID_FROM_DEVUP_AI>",
  "name": "DEVUP AI Coding Model",
  "url": "https://api.devupai.com/v1/chat/completions",
  "toolCalling": true,
  "vision": false,
  "maxInputTokens": "<CONTEXT_WINDOW_MINUS_MAX_OUTPUT>",
  "maxOutputTokens": "<MODEL_MAX_OUTPUT_TOKENS>"
}

The two token fields must be JSON numbers, not strings, after replacing the placeholders. For example, the final form should follow this shape:

{
  "maxInputTokens": 24000,
  "maxOutputTokens": 8000
}

Those numbers are only a formatting example. They are not universal model limits. Understand every field:

Calculate the input limit correctly. VS Code treats the sum of the input and output limits as the total context window:

maxInputTokens + maxOutputTokens ≤ model context window

A safe configuration is: maxInputTokens = context window − maxOutputTokens. Copy the model-specific limits from its catalog page. Do not assume that two models accept the same values.

Tool-calling rule. Set "toolCalling": true only when the selected model supports tool calling. This property informs VS Code of an existing model capability. It cannot add tool support to a model that does not already provide it.

Vision rule. Use "vision": true only when the selected model supports image input. Otherwise, keep it set to false.

Step 6: Save and Select the Model

Save chatLanguageModels.json, return to the Chat view, and open the model picker. Your configured model should appear under the DEVUP AI group. If it does not appear:

• Confirm that the JSON is valid.
• Verify that every placeholder was replaced.
• Confirm that token fields contain numbers.
• Save the file again.
• Restart VS Code.

Step 7: Validate Chat Before Enabling Tools

Do not begin by asking the model to modify an entire repository. Start with a read-only request:

Review the currently open file. Do not edit anything. Explain:

1. What the file does.
2. Its main dependencies.
3. One potential issue worth investigating.

This verifies: authentication, endpoint configuration, model selection, basic editor context, and response streaming. If this test succeeds, continue to a controlled tool test.

Step 8: Validate Tool Calling Safely

Open a small test repository and send:

Inspect this project and identify its test command. Do not modify any files. Do not run the command yet. Show me the command you found and wait for my approval.

A successful response should identify the relevant project file, locate the test command, and stop before execution. After reviewing the proposed command, approve it only if it is safe. This confirms that the model can participate in a controlled tool workflow without immediately making irreversible changes.

Step 9: Test a Real Development Task

Once the read-only and tool tests pass, try a constrained engineering task:

Analyze the failing test in this repository. Before editing:

1. Explain the probable root cause.
2. List the files you intend to change.
3. Propose the smallest safe fix.
4. Wait for approval.

After approval:

1. Apply the minimum required change.
2. Run only the relevant tests.
3. Report the exact validation result.
4. Summarize every modified file.

This prompt creates explicit checkpoints between analysis, modification, and validation. The agent produces a candidate change, but you still own the decision to accept it.

The VS Code Chat view beside an active workspace. Source: Visual Studio Code documentation.

What Works Through the Native Integration?

With a correctly configured and compatible model, the native Custom Endpoint path can provide:

• AI chat inside VS Code
• Streamed text responses
• Context from open files
• Tool-calling workflows
• Workspace file analysis
• Proposed code changes
• Terminal-assisted validation
• Multiple model entries under one DEVUP AI group
• Usage billed locally in Algerian dinars

The exact result depends on the selected model's capabilities and the permissions granted inside VS Code.

What This Integration Does Not Automatically Replace

BYOK support is powerful, but its boundaries matter.

• Inline code completion. The Custom Endpoint configuration described here powers chat and compatible tool workflows. It does not automatically replace the editor's inline code-completion system.
• Semantic search and embedding-backed features. Some semantic search and embedding-dependent capabilities can still require a separate account sign-in and are not powered by the selected BYOK chat model.
• Agent Host sessions. The standard Chat view and the separate Agents window are not identical execution surfaces. BYOK support inside Agent Host sessions has a separate experimental setting and may change. Do not assume that every model configured for Chat behaves identically in every agent interface.
• Organization policies. In managed Business or Enterprise environments, an administrator can disable Bring Your Own Key through organization policy. If the Custom Endpoint option is missing on a managed device, contact the organization administrator before changing local configuration.

Troubleshooting

For integration-specific configuration, consult the DEVUP AI VS Code guide.

A Safer Operating Checklist

Before accepting an agent-generated change:

• Review every modified file.
• Inspect terminal commands before approving them.
• Confirm that no secrets or environment files were added.
• Check that the change follows the project's existing conventions.
• Run the relevant tests yourself.
• Review the final diff before committing.
• Keep destructive operations behind explicit approval.
• Use version control before starting a multi-file task.

The correct mental model is not:

The agent wrote it, therefore it works.

It is:

The agent produced a candidate change and evidence. The developer still owns the final decision.

What Comes Next: A Dedicated DEVUP AI Extension

The native Custom Endpoint integration is available today and provides the fastest path to using DEVUP AI inside VS Code without installing an additional extension. At the same time, we are actively building a dedicated DEVUP AI extension for VS Code. Unlike a generic endpoint adapter, this extension is being designed for full, end-to-end integration with DEVUP AI and a broader set of professional development capabilities directly inside the editor.

The extension is still under active development. Its final feature set, compatibility matrix, beta availability, and release timeline will be announced after technical validation. The dedicated extension will complement the native Custom Endpoint workflow described in this guide-not make it obsolete. Developers who want immediate access can use the native integration today. Those who want the complete DEVUP AI-native editor experience can follow the platform for the upcoming extension announcement.

Final Result

VS Code's native Custom Endpoint support changes the integration equation. You can now connect DEVUP AI to the editor, select a compatible model, use streamed chat, validate tool calling, and keep billing in Algerian dinars-without installing an additional extension. The setup is small. The important part is configuring model capabilities accurately, validating them in stages, and keeping the developer in control of every consequential action.

Start here:

• Create a DEVUP AI API key
• Browse the DEVUP AI model catalog
• Open the DEVUP AI VS Code integration guide
• Read the official VS Code Custom Endpoint documentation

If you test the integration, share what you built and which VS Code workflow you want the dedicated DEVUP AI extension to improve first.