Key facts
| What it is | Self-hosted chat UI (for example Open WebUI) backed by Plugsky's API |
| Setup | Run the UI in Docker and set the OpenAI base URL to Plugsky's endpoint |
| Authentication | A Plugsky API key supplies model access; the UI manages its own users |
| Models | 30+ models appear in the model picker from one endpoint |
| Chat features | Streaming and function calling are live; capability varies by model |
| Data location | Conversation data lives in your own deployment and database |
| Free tier | Free plan with 2 free AI models, no card required |
| Deployment | Pair with VPC, on-prem or air-gapped Plugsky deployments for isolation |
TL;DR
- Any OpenAI-compatible UI works — Open WebUI is the common choice.
- Two settings matter: base URL and API key.
- Your users, history and database stay on your infrastructure.
- Model access is governed by the Plugsky key and account controls.
- Pair with a private deployment for full network isolation.
How it works, step by step
- Deploy the chat UI with Docker or your orchestrator of choice.
- Set the OpenAI-compatible base URL to Plugsky's API endpoint.
- Provide a Plugsky API key — scoped to the models and limits you intend.
- Restart the container and confirm models appear in the picker.
- Configure UI user accounts, roles and persistence for your team.
- Review data retention and backups for the UI's database before onboarding users.
Try it yourself
Open the OpenAI-compatible API tester →
Why self-host the chat layer
A hosted chat product decides where conversations live and which models you can use. Self-hosting the interface flips that: the UI, its database and its user accounts run on your infrastructure, while the model API remains a configurable dependency. Teams choose this for data-handling policy, for internal tooling that must sit behind a VPN, or simply to give everyone one interface over a multi-model catalogue.
Wiring Open WebUI to Plugsky
Open WebUI speaks the OpenAI API, so the integration is configuration. Set the OpenAI base URL to Plugsky's endpoint, paste an API key, and the model list populates from the catalogue. Because Plugsky is OpenAI-compatible, no patch or plugin is required. Keep the key in an environment variable or secret store, restart the service, and verify with a streaming request that models respond as expected.
Models, users and controls
- Model picker: expose a curated subset of the 30+ models rather than all of them, so users choose sensibly.
- API key scope: use a dedicated key for the UI; revoke it without affecting other integrations.
- UI accounts: the chat layer manages sign-in and roles; Plugsky governs model access.
- Usage visibility: API-side usage accounting shows what the deployment consumes.
- Capability checks: streaming and function calling are live; confirm per-model support in the docs.
Security and operations
Run the UI behind your VPN or identity provider, keep its database backed up and encrypted, and pin image versions instead of tracking latest. For stricter requirements, pair the UI with a private Plugsky deployment — VPC, on-prem or air-gapped — so inference traffic never leaves your network. Log administrative changes to the UI and rotate the Plugsky key on a schedule. The split of responsibilities is simple: you own the interface and its data, Plugsky owns model serving behind the endpoint.
Honest comparison
| Layer | Self-hosted UI plus Plugsky | Hosted chat product | Fully local models |
|---|---|---|---|
| UI and user data | Your infrastructure | Vendor infrastructure | Your infrastructure |
| Model access | 30+ models via one API key | Vendor catalogue only | Only models you can run |
| Hardware needs | Modest — UI only | None | Significant GPUs |
| Setup effort | Container plus two settings | Sign up | Model serving stack |
| Governance | Your accounts plus Plugsky key controls | Vendor controls | Fully yours |
Frequently asked questions
What is Plugsky Web?
A self-hosted chat interface pattern: an OpenAI-compatible UI such as Open WebUI runs on your infrastructure and connects to Plugsky's API for model access.
Does Open WebUI work with Plugsky out of the box?
Yes, through its OpenAI connection settings. Set the base URL to Plugsky's endpoint and supply an API key; the model list loads from the catalogue.
Where does conversation data live?
In the UI's own database on your infrastructure. Plugsky processes the requests you send to the model API; retention of chat history is under your control.
How many users can a self-hosted setup support?
That depends on your container resources and database, not on Plugsky's API. Scale the UI horizontally and use a managed database for larger teams.
Can I restrict which models are visible?
Yes. Curate the model list in the UI so users see an approved subset of the 30+ available models rather than the entire catalogue.
Does this work in an air-gapped network?
Yes. Combine the self-hosted UI with a private Plugsky deployment — VPC, on-prem or air-gapped — so neither chat nor inference traffic leaves your network.