IDE Integrations

Use UMVA AI With Your Favorite Editor

UMVA AI provides an Anthropic-compatible API that works with any IDE supporting custom AI endpoints. Use our native IDE with zero setup, or configure your existing editor. The editor registers exactly one native provider (id: "umva") and fetches models on startup from our API.

UMVA AI IDE — The Native Way

Pre-configured, zero-setup AI coding environment

Editor Auth Flow

The IDE uses an OAuth-like browser-based token exchange. No manual copy-pasting required.

  1. Download and install the UMVA AI IDE for your platform.
  2. The editor opens https://umva.net/account?redirect=umva-editor://callback in your browser.
  3. If logged in, you see "Authorize Editor". If not, login first.
  4. Click "Authorize Editor" — an API key named "IDE" is created.
  5. Browser redirects to umva-editor://callback?token=umva_ai_xxx... and the editor stores the token.

Manual API Key Setup

You can also generate an API key manually from your dashboard.

  1. Log in at umva.net
  2. Navigate to AI API Keys in your sidebar.
  3. Click "Generate New AI API Key", name it, and copy the key.
  4. Set it as the UMVA_API_KEY environment variable in your editor.
  5. The same key works for both the editor and direct API calls.
Bearer Token: Authorization: Bearer umva_ai_YOUR_API_KEY_HERE

Third-Party Editor Integrations

Our Anthropic-compatible API works with any tool that supports custom AI endpoints

VS Code

Use the Continue.dev extension or configure the built-in AI endpoints to point to the UMVA API. Our Anthropic-compatible API works with any VS Code AI extension.

Continue.dev Custom Endpoint
Cursor

Cursor supports custom OpenAI-compatible API endpoints. Configure the UMVA AI endpoint and use pay-as-you-go AI without Cursor's subscription fees. Use our model IDs directly.

Custom API Anthropic Compat
JetBrains IDEs

IntelliJ, PyCharm, WebStorm, GoLand and all JetBrains IDEs. Use the Continue.dev plugin or configure the built-in AI Assistant with our Anthropic-compatible API.

Continue.dev AI Assistant
Neovim

Use with llm.nvim, Continue.nvim, or gen.nvim. Our Anthropic-compatible API works with all Neovim AI plugins that support custom endpoints. Configure the base URL and API key.

llm.nvim Continue.nvim
Emacs

Use with gptel, ellama, or aider.el. Configure the API endpoint and model to start using UMVA AI from within Emacs for code completions, chat, and refactoring.

gptel ellama
Windsurf

Windsurf supports custom AI providers. Configure the UMVA AI API as your Anthropic-compatible provider endpoint to use our models with Windsurf's AI features.

Custom Provider Anthropic Compat

API Configuration Reference

The exact settings to use in your IDE or tool

API Base URLs
https://umva.net
https://umva.us
The editor retries fallback on network error or 5xx status.
Authentication
Authorization: Bearer umva_ai_YOUR_API_KEY_HERE
Get your API key from your UMVA dashboard or use the editor auth flow.
Content-Type: application/json
User-Agent: umva-ai-editor/1.0
X-Request-Id: <uuid>
X-Client-Version: <editor version>

API Endpoints

The endpoints your IDE will call

Method Endpoint Purpose
GET /api/llm/models Fetch available models on IDE startup
POST /api/llm/completion Send messages and get SSE streaming responses

Quick Setup Guides

Get started with your editor in minutes

VS Code Setup
  1. Install the Continue.dev extension from the VS Code marketplace.
  2. Open Command Palette (Cmd+Shift+P) → "Continue: Open Config".
  3. Add UMVA as an Anthropic-compatible provider with base URL https://umva.net
  4. Set your API key as Bearer token and model to umva-code-fast
  5. Use AI code completion, chat, and edits — pay only for tokens.
UMVA AI IDE
  1. Download and install on macOS, Windows, or Linux (native, no Electron).
  2. Launch the editor — it opens https://umva.net/account?redirect=umva-editor://callback
  3. Sign in and click "Authorize Editor" — token is set automatically.
  4. The editor fetches models via GET /api/llm/models on startup.
  5. Start coding with AI agent, chat, completions, and git built-in.
JetBrains Setup
  1. Install the Continue.dev plugin from the JetBrains marketplace.
  2. Open Settings → Tools → Continue → Add custom provider.
  3. Set provider type to Anthropic, base URL to https://umva.net
  4. Enter your API key and model (e.g. umva-code-pro for complex tasks).
  5. Use AI Assistant for code gen, debugging, and refactoring.
Neovim Setup (llm.nvim)
  1. Install llm.nvim via your plugin manager (lazy.nvim, packer).
  2. Configure the Anthropic-compatible client with base URL https://umva.net
  3. Set your Bearer token and default model (umva-code-fast).
  4. Use :LLMSessionManager to start chatting with the AI.
  5. Enjoy AI completions, chat, and refactoring in Neovim.

Streaming Response (SSE)

How the IDE processes real-time AI responses

The API returns Server-Sent Events with event and data lines. The IDE processes these events in real-time:

SSE Event When Data
pingOn connect{}
message_startResponse starts{"type":"message_start","message":{"id":"msg_..."}}
content_block_startBlock starts{"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
content_block_deltaText streaming{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}
content_block_deltaTool call{"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"{\"path\":"}}
content_block_deltaThinking{"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"..."}}
message_deltaFinal usage{"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input_tokens":50,"output_tokens":150}}
message_stopComplete{"type":"message_stop"}
text Displayed as message text tool_use Triggers tool execution thinking Collapsible reasoning block

Custom Protocol Handler

For custom IDE integrations that use the OAuth auth flow

macOS (Swift)
// In Info.plist
<key>CFBundleURLTypes</key>
<array><dict>
  <key>CFBundleURLSchemes</key>
  <array><string>umva-editor</string></array>
</dict></array>

// In AppDelegate
func application(_ app: NSApplication,
  open urls: [URL]) {
  guard let token =
    URLComponents(url: urls[0])?
    .queryItems?.first(where:
    { $0.name == "token" })?.value
  else { return }
}
Windows (Registry)
HKEY_CLASSES_ROOT\umva-editor
  (Default) = "URL:UMVA Editor Protocol"
  URL Protocol = ""
  \shell\open\command
    (Default) = ""
    C:\Program Files\UMVA\
    editor.exe" "%1""
Linux (.desktop)
[Desktop Entry]
Type=Application
Name=UMVA Editor
Exec=/opt/umva-editor/editor %u
MimeType=x-scheme-handler/
  umva-editor;
Electron / Tauri
// Register on app start
app.setAsDefaultProtocolClient(
  "umva-editor");

// macOS: handle open-url
app.on("open-url", (event, url) => {
  event.preventDefault();
  const token = new URLSearchParams(
    url.split("?")[1]).get("token");
  if (token) storeToken(token);
});

// Win/Linux: handle second-instance
app.on("second-instance",
  (event, argv) => {
  const url = argv.find(a =>
    a.startsWith("umva-editor://"));
  if (url) {
    const token = new URLSearchParams(
      url.split("?")[1]).get("token");
    if (token) storeToken(token);
  }
});

Works With Your Workflow

No matter which editor you use, UMVA AI fits right in. Start integrating today.