Knowledge Base Sections ▾
Navigation
▸ Start here By rolesCategories
- Cursor + Gonka AI - cheap LLM for coding
- Claude Code + Gonka AI - LLM for the terminal
- OpenClaw + Gonka AI - affordable AI agents
- OpenCode: your own model in the terminal
- Continue.dev + Gonka AI - AI for VS Code/JetBrains
- Cline + Gonka AI - AI agent in VS Code
- Aider + Gonka AI - pair programming with AI
- LangChain + Gonka AI - AI applications for pennies
- n8n + Gonka AI - automation with cheap AI
- Open WebUI + Gonka AI - your own ChatGPT
- LibreChat + Gonka AI — open-source ChatGPT
- Hermes Agent + DeepSeek on the Gonka network — an autonomous agent for pennies
- Kilo Code + Gonka AI — AI-Agent in VS Code
- Roo Code + Gonka AI — Autonomous AI Agent in VS Code
- LlamaIndex + Gonka AI — RAG applications for pennies
- PydanticAI + Gonka — typed AI agents for pennies
- Vercel AI SDK + Gonka AI — AI applications in TypeScript for pennies
- TanStack AI + Gonka — AI applications in TypeScript for pennies
- API quick start — curl, Python, TypeScript
- JoinGonka Gateway — a full overview
- Management Keys — SaaS on Gonka
- Cheapest AI API: Provider Comparison 2026
- Cursor Pro request limit reached — breakdown and cheaper alternative
- Claude Code is cheaper — bill breakdown and switching
- Cline is burning money — why the agent spends so much
- OpenClaw is expensive — why the agent burns through tokens and how to save
- OpenRouter: Cheap Alternative — Comparison with JoinGonka Gateway
- Best AI model for coding in 2026: comparison and prices
- Cheap alternative to GitHub Copilot without limits
- A cheap Windsurf alternative without credits or limits
- The cheapest API for AI agents in 2026
- ZCode: Cheap GLM inference instead of GLM Coding Plan
- JetBrains IDE + JoinGonka Gateway — your own endpoint instead of credits
- GitHub Copilot BYOK — own models instead of quotas
- Zed + JoinGonka Gateway — cheap inference in your editor
- Pi + JoinGonka Gateway — terminal agent on cheap inference
- Codex CLI: your own key instead of a subscription
Tools
Continue.dev + Gonka AI - AI for VS Code/JetBrains
Continue.dev - the most popular open-source AI extension for VS Code and JetBrains IDEs. Code autocompletion, built-in chat, generation by comments, code explanation - functionality at the level of GitHub Copilot, but free and customizable.
Continue.dev supports dozens of LLM providers, including OpenAI-compatible APIs. This means that JoinGonka Gateway connects in one minute - by editing one JSON file.
Result: GitHub Copilot functionality ($19-39/month) for $0.30/month via Gonka.
Step 1: Install Continue.dev
Install the extension from the marketplace:
- VS Code: Extensions → Search "Continue" → Install.
- JetBrains (IntelliJ, PyCharm, WebStorm, GoLand): Settings → Plugins → Marketplace → "Continue" → Install.
After installation, the Continue icon will appear in the sidebar. If you are using Continue for the first time, the extension will offer to configure the LLM provider on the first launch.
Step 2: Configure Gonka provider
The easiest way is to set it up using the one-command installer. For CLI/file tools, it will automatically configure the JoinGonka provider (baseUrl, models), and for UI tools, it will display the values ready for you to paste:
npx @joingonka/setup --tool continueThe installer is universal (if no flag is provided, it will prompt you to select a tool from the list), it will ask for your jg-… key, and after setup, it performs a live check by sending a request to the gateway. It does not touch other settings. Below is the manual method if you prefer to set it up yourself.
Manual Setup (Plan B)
Continue uses ~/.continue/config.yaml (the old config.json format is deprecated). Open it via the command palette: Ctrl+Shift+P (on macOS, Cmd+Shift+P) → "Continue: Open config.yaml".
Add JoinGonka Gateway as a provider:
# ~/.continue/config.yaml
models:
- name: Gonka DeepSeek V4 Flash
provider: openai
model: deepseek-ai/DeepSeek-V4-Flash-0731
apiBase: https://gate.joingonka.ai/v1
apiKey: jg-your-key
roles: [chat, edit, apply]
capabilities: [tool_use]
- name: Gonka Kimi K2.6
provider: openai
model: moonshotai/Kimi-K2.6
apiBase: https://gate.joingonka.ai/v1
apiKey: jg-your-key
roles: [chat, edit, apply]
capabilities: [tool_use]
- name: Gonka MiniMax M2.7
provider: openai
model: MiniMaxAI/MiniMax-M2.7
apiBase: https://gate.joingonka.ai/v1
apiKey: jg-your-key
roles: [chat, edit, apply]
capabilities: [tool_use]
- name: Gonka Autocomplete
provider: openai
model: deepseek-ai/DeepSeek-V4-Flash-0731
apiBase: https://gate.joingonka.ai/v1
apiKey: jg-your-key
roles: [autocomplete]Continue displays models with chat, edit, apply roles in a list—you can switch directly in the chat: Gonka DeepSeek V4 Flash handles a 380K context and up to 32768 output tokens (good for large files and long edits), Kimi K2.6 is stronger at reasoning, while MiniMax M2.7 is faster for short responses. DeepSeek V4 Flash is set for autocomplete, and this is not just preference: Continue selects the prompt format based on the model NAME, and among the network models, only DeepSeek understands it. MiniMax and Kimi will respond to the same formatting with reasoning instead of code, resulting in garbage suggestions.
Autocomplete via a decentralized network is slower than Copilot: about two seconds per suggestion versus a fraction of a second. Chat, edits, and agent mode are not affected by this.
The line capabilities: [tool_use] is mandatory for agent mode. Continue only enables tools for models in its own list (gpt-*, o*, codex*)—Gonka models are not there, and without this line, the agent remains tool-less: it cannot read files or edit code, and the chat cannot see the project. The gateway itself supports tool-calling.
Project indexing (@codebase) requires an embedding model—there are currently none in the Gonka network. Add context via @file and @folder or work in agent mode, where it reads files using tools.
To avoid keeping the key in plain text, Continue supports apiKey: ${{ secrets.GONKA_API_KEY }} substitution with a variable in ~/.continue/.env.
Verification: open any code file and start typing—autocomplete should work. Or open the Continue chat (Ctrl+L) and ask a question.
Important: ensure apiBase ends with /v1 at the end of the URL. Without it, requests will return 404.
Continue.dev vs GitHub Copilot
Let's compare Continue.dev + Gonka with GitHub Copilot — the most popular commercial alternative:
| Parameter | Continue.dev + Gonka | GitHub Copilot |
|---|---|---|
| Price/month | ~$0.30 | $19 (Individual) / $39 (Business) |
| Open-source | Yes (Apache 2.0) | No |
| IDE | VS Code, JetBrains | VS Code, JetBrains, Neovim |
| Model | Kimi K2.6 (customizable) | GPT-5.5 (fixed) |
| Privacy | Via decentralized network | Data on Microsoft servers |
| Limits | No limits | Limit on completions/day |
| Model config | Any OpenAI-compatible | GitHub models only |
| Model context | 200K tokens | 128K (GPT-5.5) |
| Max response length | up to 8192 tokens (Gateway, for all network models) | Depends on the model |
Continue.dev + Gonka is 60-130 times cheaper, fully open-source, unlimited, and allows model selection. The only advantage of Copilot is deeper GitHub integration (pull request review), but for daily coding, Continue.dev + Gonka covers 95% of needs.