How do MSPs build multimodal AI with Plugsky's architecture?

Key facts

MSP fit	Workspace per client with tenant-scoped keys and vector namespaces
Live endpoints	Chat completions with streaming, function calling, JSON mode and embeddings
Coming soon	Audio, images, files and batch endpoints are labelled coming soon
Models	30+ models behind one OpenAI-compatible API
Isolation	Workspaces, scoped API keys, RBAC and SSO/SCIM
Pricing	Flat monthly self-serve plans with unlimited fair-use usage; no per-token billing
Free plan	plugsky-micro and plugsky-lite, no card; 14-day full-access trial
Deployment	Plugsky cloud, your VPC, on-prem and air-gapped

TL;DR

• Keep the reasoning core on live chat completions, JSON mode, function calling and embeddings.
• Treat OCR and transcription as a swappable adapter; audio, images and files are coming soon.
• Give every client a workspace, scoped keys and a tenant-scoped vector namespace.
• Route cheap classification to plugsky-micro and escalate only hard extractions.
• Flat monthly plans protect reseller margin; begin free, then use the 14-day full-access trial.

How it works, step by step

1. Pick one repeatable client workflow — invoice extraction, ticket triage or call summarisation — and write down its inputs, outputs and SLA.
2. Create a workspace per client and issue scoped API keys per environment; keep them in your secret manager, never in client environments.
3. Keep extraction behind a swappable adapter so the OCR or transcription engine can change without touching the reasoning core.
4. Structure outputs with JSON mode, then retrieve context with the embeddings API from a tenant-scoped vector namespace.
5. Route classification to plugsky-micro or plugsky-lite and reserve larger models for hard extractions through the same endpoint.
6. Record model, token and tenant metadata on every call, reconcile usage monthly, and only then onboard the next client.

Try it yourself

Open the Chat with PDF tool →

Why MSPs need a multimodal pipeline

MSPs already sit on the document-heavy edge of every client: invoices, purchase orders, contracts, support tickets and call recordings. Text-only AI misses most of that input, so the practical pattern is a pipeline that normalises each file into text or structured fields, reasons over it, then triggers an action in a PSA, ticketing or accounting system.

Plugsky keeps that reasoning core behind one OpenAI-compatible API, so you productise a single service and resell it to many clients instead of maintaining a separate integration for every model vendor.

Reference architecture: ingest, extract, reason, act

Stage one is ingest and extraction. Audio, images and files endpoints are still coming soon, so keep this stage behind a swappable adapter — a document parser, an OCR engine or a transcription service — and normalise output to text or JSON. Stage two is structuring with JSON mode against a strict per-tenant schema: invoice number, supplier, totals, or ticket category, confidence and severity.

Stage three is retrieval: embed knowledge and history with the embeddings API into a tenant-scoped vector namespace, then re-rank before prompting. Stage four is reasoning and action through chat completions: draft the reply, classify the escalation or emit a function call that opens a ticket. Stage five is metering — record model, tokens and tenant on every call so you can bill and capacity-plan.

Tenant isolation, residency and margin

Give each client a workspace with scoped API keys and RBAC, keep vector namespaces tenant-scoped, and never place one client's key in another client's environment. Where a client requires in-country processing, pin the workspace to a region-locked plane — EU (Frankfurt), GCC (UAE), APAC (Singapore) or US (Virginia) — or move to VPC, on-prem or air-gapped deployment.

Flat monthly plans with unlimited fair-use usage protect your margin: there is no per-token gross-up to renegotiate with every client. Review the DPA for retention terms, export authentication and key events to your SIEM, and state clearly in client SLAs that audio, image and file endpoints are still roadmap items. See the live pricing page for current plans.

Honest comparison

Stage	Plugsky	Typical multimodal stack	Building in-house
Reasoning core	Live chat completions, streaming, function calling	Vendor-specific SDK per model	Serve and tune models yourself
Extraction	JSON mode live; audio, images and files coming soon	Separate OCR and speech vendors	Integrate every pipeline
Retrieval	Embeddings API plus your vector store	Another vendor and another bill	Build and index yourself
Isolation	Workspace, scoped keys and RBAC per client	Shared projects with weak separation	Custom auth and quota code
Cost model	Flat monthly plans, no per-token on self-serve	Per-token costs across several vendors	GPU capacity plus ops headcount

Frequently asked questions

Which multimodal endpoints are live today?

Chat completions with streaming, function calling and JSON mode, plus embeddings, are live. Audio, images, files and batch endpoints are labelled coming soon, so check the docs before promising them in a client SLA.

How do MSPs isolate each client's data?

Use a workspace per client with scoped API keys and role-based access, keep vector namespaces tenant-scoped, and export authentication and key events to your SIEM.

Can we resell Plugsky under our own brand?

Yes. MSPs typically wrap the API in their own service and keep the OpenAI-compatible endpoint behind their gateway. Confirm commercial terms on the live pricing page.

How do we control cost across tenants?

Route classification and routing to plugsky-micro or plugsky-lite and reserve larger models for hard extractions. Self-serve plans are flat monthly with fair-use usage, not per-token billing.

Does the pipeline work inside a client's network?

Enterprise deployment options include your VPC, on-prem and air-gapped, and they expose the same OpenAI-compatible API surface.

What should we build first?

One document-heavy workflow such as invoice extraction or ticket triage, with a measured baseline and a per-tenant evaluation set, before expanding to more clients.

Do we need to rewrite existing OCR integrations?

No. Keep the extraction stage swappable and call Plugsky for reasoning, retrieval and actions through the OpenAI-compatible API.