Potencialize seu agente
O comando do próprio publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
docker run -i --rm ghcr.io/helv-io/skgate:0.28.1O Claude Code não tem link de instalação para um comando local. Copie o comando abaixo e execute-o em um terminal.
PUBLIC_URL=<value> OIDC_ISSUER=<value> OIDC_CLIENT_ID=<value> OIDC_CLIENT_SECRET=<secret> claude mcp add helv-io-skgate -- docker run -i --rm ghcr.io/helv-io/skgate:0.28.1Execute em um terminal.
{ "mcpServers": { "helv-io-skgate": { "command": "docker", "args": [ "run", "-i", "--rm", "ghcr.io/helv-io/skgate:0.28.1" ], "env": { "PUBLIC_URL": "<value>", "OIDC_ISSUER": "<value>", "OIDC_CLIENT_ID": "<value>", "OIDC_CLIENT_SECRET": "<secret>" } } }}claude_desktop_config.json
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDo publicador
Self-hosted MCP gateway and LLM proxy. Serve any MCP server or REST API behind OAuth 2.1, run stdio/git MCP servers on demand, and proxy AI providers (OpenAI, Anthropic, Gemini, Grok, Ollama) through one OpenAI-compatible API with model aliases and virtual keys. Grok subscription works with no API key.
skgate /ɛsˈkɑːɡeɪt/ (ess-KAH-gate)
"sk" is how a lot of SI API keys start, and "gate" is for gateway. Not a great name, but it's ours.
The plane in the logo is an inside joke. The public wouldn't understand it, and I'm not about to explain it. Sorry.
Yes
You need an OIDC provider with a confidential client for skgate. Admin login is OIDC only. Trying it on one machine? docs/quickstart.md runs skgate with a bundled provider and no accounts.
# docker-compose.yml
services:
skgate:
container_name: skgate
image: ghcr.io/helv-io/skgate:latest
restart: always
ports:
- 8080:8080
environment:
- PUBLIC_URL=https://skgate.example.com
- OIDC_ISSUER=https://auth.example.com
- OIDC_CLIENT_ID=skgate
- OIDC_CLIENT_SECRET=change-me
volumes:
- ./data:/data
healthcheck:
test: ["CMD", "/skgate", "healthcheck"]
interval: 30s
timeout: 5s
retries: 3
docker compose up -dhttps://skgate.example.com/admin and sign in through your OIDC provider.https://skgate.example.com/mcp or the site root for every included upstream, or at https://skgate.example.com/mcp/<alias> for one upstream. Sign in when it asks.Image tags:
latest: proxy + managed MCP servers. Bundles Node.js (npx), pnpm, Bun (bunx), Deno, Python (uv, uvx), Go, .NET and git.slim: proxy onlyTo upgrade, back up ./data, then docker compose pull && docker compose up -d.
skgate is also an OpenAI-compatible API in front of your SI providers. Point your apps at one address; switch the provider behind them without changing the apps. User-defined model aliases give your apps a stable model name of your choosing.
Grok can use subscription sign-in with no API key. Other providers use that provider's API key (OpenAI, Anthropic, Gemini, Mistral, DeepSeek, Groq, OpenRouter, Ollama, LM Studio, and any OpenAI-compatible endpoint).
sk-... key; it is shown once.https://skgate.example.com/v1, API key sk-... (see Examples).
/v1, /api, /api/v1, and the bare host. Use whichever form your client expects.export SKGATE=https://skgate.example.com KEY=sk-...
curl -s $SKGATE/v1/models -H "Authorization: Bearer $KEY"
curl -s $SKGATE/v1/chat/completions -H "Authorization: Bearer $KEY" \
-H 'Content-Type: application/json' \
-d '{"model":"<id from /v1/models>","messages":[{"role":"user","content":"Say hi"}]}'
export OPENAI_BASE_URL=https://skgate.example.com/v1 OPENAI_API_KEY=sk-...
from openai import OpenAI
client = OpenAI() # reads the two variables above
r = client.chat.completions.create(model="<id from /v1/models>", messages=[{"role": "user", "content": "Say hi"}])
print(r.choices[0].message.content)
Aliases are user-defined: skgate ships with none. Pick any name and point it at a model. This example uses grok-latest, but the name is up to you.
Change the target in this one place and every app using that name switches at once, with no client config changes.
Grok > Aliases: New alias grok-latest, Target model grok-4.7, Add alias.
client sends {"model": "grok-latest", ...}
skgate sends {"model": "grok-4.7", ...}
Aliases are listed first in /v1/models.
Needs the latest image and an MCP helper model from any ready provider. The first time, Pick MCP helper model next to the button opens the model picker right on the page.
mcp upstreams > Add upstream > Type managed process:
MCP source URL / package, one of:
Suggest configuration. skgate fetches the README and manifests (package.json, pyproject.toml, server.json).
The MCP helper model proposes the command, args, install step, and env names (secret or not, required or optional). The Manual configuration fields fill in, with a confidence and any warnings.
Nothing is saved yet. Set the variables the server needs.
Set an alias, fill in the variables you need (empty ones are not passed to the server), Save. The server is at https://skgate.example.com/mcp/<alias>.
If the button is greyed out, hover it. Use Pick MCP helper model beside it, or add a provider on status first.
Hosted connectors use OAuth (leave client ID and secret empty). Scripts and CLIs send a key:
{"mcpServers": {"skgate": {"type": "http", "url": "https://skgate.example.com/mcp/<alias>",
"headers": {"Authorization": "Bearer sk-..."}}}}
On a RAM-constrained homelab, idle MCP servers should cost nothing.
Managed servers (npx, pnpm dlx, bunx, deno, uvx, git) are child processes of skgate.
By default (Lifecycle on-demand) one starts on its first request and stops after 10 minutes without requests; the next request starts it again.
before 3 MCP servers = 3 containers, always running
after 1 skgate container; 0 server processes while idle, 1 per server in use
stopped --request--> starting --> running --10 min idle--> stopped
always-on starts the server at boot instead.idleTimeoutSeconds in import JSON (default 600; not in the form):{"mcpServers": {"time": {"command": "uvx", "args": ["mcp-server-time"], "skgate": {"idleTimeoutSeconds": 120}}}}
/mcp includes remote, OpenAPI and always-on upstreams marked In /mcp. On-demand servers are left out, so /mcp never starts them. Point a client at /mcp/<alias> to use one.mcp upstreams > import JSON > paste > Import. Needs the latest image.
{"mcpServers": {"everything": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-everything"]}}}
Served at https://skgate.example.com/mcp/everything. The same package runs with any bundled runner:
mcp upstreams > import JSON > paste > Import. skgate clones the repo, runs install, then the command.
{"mcpServers": {"notes": {"command": "node", "args": ["server.js"],
"skgate": {"gitUrl": "https://github.com/example-org/notes-mcp.git", "gitRef": "main", "install": "npm ci"}}}}
mcp upstreams > Add upstream > Type remote server, or import:
{"mcpServers": {"docs": {"type": "http", "url": "https://mcp.example.com/mcp",
"headers": {"Authorization": "Bearer ..."}}}}
Clients tested by the author against a live skgate. Status is what happened, not a promise.
skgate stdio starts a small read-only MCP server on stdin and stdout. It exists so MCP directories and scanners, which start a server and ask what it offers, can look at skgate. It is not for real use: to run skgate, use the Docker image above.
It needs no settings, opens no port, reads no database and uses no network. It has three tools: about, list_features and config_help. They describe skgate and nothing else. More in docs/mcp.md.
A rough guide from each project's docs as of 2026-10-13. Check them for current features.
How each provider signs in elsewhere, and how skgate connects to it:
* Free tier available.
As of 2026-10-05; check each provider's terms. GitHub Copilot is not a skgate provider.
Set these under environment: or in an env_file. Placeholders are in .env.example.
Grok needs no variables. Sign in on the status page. Model aliases are the Aliases control on that card.
Everything lives in /data (skgate.db, secrets.key): back up both.
Set PUBLIC_URL to the public https origin.
Do not put forward-auth on /v1, /api, /mcp, /sse, /messages, /authorize, /token, /register, or /.well-known.
Only Traefik is tested by the author. Open an issue with what you tried.
services:
skgate:
container_name: skgate
image: ghcr.io/helv-io/skgate:latest
restart: always
network_mode: web # existing Docker network shared with Traefik; no ports needed
environment:
- PUBLIC_URL=https://skgate.example.com # the public https origin
- OIDC_ISSUER=https://auth.example.com
- OIDC_CLIENT_ID=skgate
- OIDC_CLIENT_SECRET=change-me
volumes:
- ./data:/data
healthcheck:
test: ["CMD", "/skgate", "healthcheck"]
interval: 30s
timeout: 5s
retries: 3
labels:
# no forward-auth middleware on /v1, /api, /mcp, /sse, /messages, /authorize, /token, /register, /.well-known
- traefik.enable=true
- traefik.http.routers.skgate.rule=Host(`skgate.example.com`)
- traefik.http.routers.skgate.entryPoints=websecure
- traefik.http.services.skgate.loadbalancer.server.port=8080
server {
listen 443 ssl;
http2 on;
server_name skgate.example.com;
ssl_certificate /etc/ssl/skgate/fullchain.pem;
ssl_certificate_key /etc/ssl/skgate/privkey.pem;
client_max_body_size 32m; # skgate accepts up to 32 MB
location / {
proxy_pass http://skgate:8080;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host; # keep Host
proxy_set_header X-Forwarded-For $remote_addr;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_buffering off; # SSE streaming
proxy_read_timeout 3600s; # long streams
proxy_send_timeout 3600s;
}
}
skgate.example.com {
# Host and X-Forwarded-* are set by default; no body limit, no response timeout
reverse_proxy skgate:8080 {
flush_interval -1 # SSE streaming
}
}
defaults
mode http
timeout connect 5s
timeout client 1h # long streams
timeout server 1h
timeout tunnel 1h
frontend https
bind :443 ssl crt /etc/haproxy/certs/skgate.pem alpn h2,http/1.1
option forwardfor # X-Forwarded-For; Host is kept, responses are not buffered
http-request set-header X-Forwarded-Proto https
default_backend skgate
backend skgate
option httpchk GET /healthz
server skgate skgate:8080 check
# a2enmod ssl proxy proxy_http headers
<VirtualHost *:443>
ServerName skgate.example.com
SSLEngine on
SSLCertificateFile /etc/ssl/skgate/fullchain.pem
SSLCertificateKeyFile /etc/ssl/skgate/privkey.pem
# keep Host
ProxyPreserveHost On
RequestHeader set X-Forwarded-Proto "https"
# long streams
ProxyTimeout 3600
# flushpackets: no buffering (SSE)
ProxyPass / http://skgate:8080/ flushpackets=on
ProxyPassReverse / http://skgate:8080/
</VirtualHost>
Without OIDC_ISSUER, OIDC_CLIENT_ID and OIDC_CLIENT_SECRET, skgate starts but the admin stays closed.
Every user your provider lets in is an admin. Restrict the provider, or set OIDC_ALLOWED_EMAILS / OIDC_ALLOWED_GROUPS.
Hints for Authelia, Authentik, Keycloak, Zitadel and Pocket ID: docs/oidc.md.
/authorize needs an admin session.slim image to disable them./register, /token, /authorize and admin forms cut off a request body that arrives too slowly. Uploads and streams (/v1, /mcp) have no such limit.?key=) for clients that cannot send headers. It is off per key by default, because URLs leak into logs, history and referrers.More, including the known trade-offs: operations.
skgate is built with SI assistance: coding agents write much of the code, tests and docs.
Every change is reviewed by the author, and the security paths (OAuth, tokens, secrets) are human reviewed and tested. Reviews by frontier models are a supplement, not a substitute. Issues and pull requests that put it to the test are welcome.
go build ./... && go vet ./... && go test ./...
docs/development.md. Contributors and agents: AGENT.md.
MIT, see LICENSE.
Self-hosted MCP gateway and LLM proxy. Serve any MCP server or REST API behind OAuth 2.1, run stdio/git MCP servers on demand, and proxy AI providers (OpenAI, Anthropic, Gemini, Grok, Ollama) through
{ "mcpServers": { "helv-io-skgate": { "command": "docker", "args": [ "run", "-i", "--rm", "ghcr.io/helv-io/skgate:0.28.1" ], "env": { "PUBLIC_URL": "<value>", "OIDC_ISSUER": "<value>", "OIDC_CLIENT_ID": "<value>", "OIDC_CLIENT_SECRET": "<secret>" } } }}Visão geral
Self-hosted MCP gateway and LLM proxy. Serve any MCP server or REST API behind OAuth 2.1, run stdio/git MCP servers on demand, and proxy AI providers (OpenAI, Anthropic, Gemini, Grok, Ollama) through one OpenAI-compatible API with model aliases and virtual keys. Grok subscription works with no API key.
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
O publicador lista estas variáveis de ambiente: PUBLIC_URL, OIDC_ISSUER, OIDC_CLIENT_ID, OIDC_CLIENT_SECRET.
Skgate roda localmente via stdio.
Última verificação: 2026-11-13. Self-hosted MCP gateway and LLM proxy. Serve any MCP server or REST API behind OAuth 2.1, run stdio/git MCP servers on demand, and proxy AI providers (OpenAI, Anthropic, Gemini, Grok, Ollama) through one OpenAI-compatible API with model aliases and virtual keys. Grok subscription works with no API key.