Skip to content
Logo: WECORE
Register / Login
LLMaaS
Available on request

Launch open LLMs on GPUs you control.

A self-hosted LLM launcher for your WECORE cloud. Pick an open model from Hugging Face, deploy it on GPU nodes in one step, and get a ready chat interface plus an OpenAI-compatible API — served by vLLM, with prompts and data that never leave your infrastructure.
vLLM inference engine
OpenAI-compatible API
Open Hugging Face models
Private by design
Early-access module: LLMaaS — built on WECORE GPU and Cloud Server primitives.

Illustrative interface — your model, your endpoint, your data.

vLLM
High-throughput serving engine
OpenAI-compatible
Drop-in /v1 chat & completions API
Open models
Llama, Qwen, Mistral, DeepSeek & more
Self-hosted
Runs on your GPUs, data stays put
Workflow

From model to endpoint, without leaving your cloud.

Inspired by the Azimuth LLM launcher, WECORE turns a chosen open model into a running chat app and API on your own GPU nodes — no inference plumbing to build.
01

Pick a model

Choose from curated open models or point at any vLLM-supported repository on Hugging Face — instruct, chat, code, embedding, or vision-language.

02

Size the GPUs

Select a GPU flavor and starting size from your WECORE GPU capacity. Preflight checks confirm VRAM and quota fit the model before it launches.

03

Launch in one step

WECORE deploys vLLM and a chat web app for you — model weights pulled, served, and health-checked, exposed behind your own per-service API key.

04

Chat and integrate

Use the built-in web chat, or point your apps at the OpenAI-compatible endpoint. Watch tokens/sec, latency, and GPU use on the built-in dashboards.

Use cases

One launcher, many AI workloads.

Each lane ships with curated model presets, the right GPU sizing, and a chat or API surface tuned to the job.
Chat + retrieval

Chat & RAG assistants

Stand up an internal assistant or a retrieval-augmented chatbot over your own documents — a private alternative to public chat services, with sources that stay inside your network.

Llama 3.1 Qwen2.5 Mistral Embeddings
Developer tooling

Code & agents

Serve a code model behind the OpenAI-compatible API to power IDE assistants, code review bots, and tool-using agents — billed as GPU time, not per-token to a vendor.

Qwen2.5-Coder DeepSeek-Coder Devstral
Multimodal

Vision & document AI

Deploy a vision-language model for image understanding, screenshot Q&A, and document extraction with the image-analysis interface, all on accelerated nodes.

Llama 3.2 Vision Qwen2-VL Pixtral
Platform

A thin control plane over proven open inference.

LLMaaS is not another model. It is the governed product layer that assembles vLLM, open weights, and a web UI on GPU capacity you already own.
llm-launch self-hosted
model:   meta-llama/Llama-3.1-8B-Instruct
backend: vllm (openai-compatible)
gpu:     1 × A100-80GB
ui:      web chat + image analysis
expose:  https + per-service API key
status:  SERVING  ·  142 tok/s

Curated model catalog

Start from vetted open models with sane defaults, or bring any vLLM-supported Hugging Face repository — gated weights pulled with your own token.

OpenAI-compatible endpoint

A stable /v1 chat and completions API means existing SDKs, agents, and tools point at WECORE by changing one base URL.

Fit checked before spend

Each model runs as a managed service on a dedicated server, and the fit — GPU memory, context bounds, plan eligibility — is checked before anything is created.

Built-in observability

Ready dashboards surface throughput, latency, queue depth, and GPU utilization from day one.

Private by design

Prompts, completions, and weights stay on operator storage inside your cloud — no third-party API calls, no data egress to a model vendor.

Quota & cost preflight

Estimate VRAM, GPU hours, and wallet impact before a model launches, and stop paying the moment you stop an idle model.

Open stack

The best open inference, assembled and governed.

LLMaaS packages the same components research and platform teams already trust, behind one self-service launch flow.

Inference

vLLM OpenAI-compatible server Hugging Face weights GPU acceleration

Interfaces

Web chat UI Image analysis UI REST + SDKs Streaming responses

Models

Llama Qwen Mistral DeepSeek Gemma Embeddings

Platform

Your own GPU capacity Dedicated server per service Per-service API keys Metrics & dashboards
Why WECORE Cloud

API-like experience, self-hosted execution.

Dimension
Hosted LLM APIs
WECORE LLMaaS
Where it runs
Vendor SaaS, shared tenancy
GPU capacity you own, inside your cloud
Data residency
Prompts and data leave your network
Prompts, weights, and logs stay on your cloud
Model control
Provider's models and versions
Any open vLLM-supported model, pinned by you
Integration
Proprietary endpoints
OpenAI-compatible API — change one base URL
Cost model
Per-token, metered per request
GPU time you own; stop an idle model, stop paying
FAQ

LLM-as-a-Service questions, answered

What the launcher is, what it serves, and how it fits WECORE infrastructure

It is a self-hosted LLM launcher: you choose an open model, and WECORE deploys it on your GPU nodes with a chat web interface and an OpenAI-compatible API. The pattern is inspired by StackHPC's Azimuth LLM apps, adapted to run on WECORE GPU infrastructure.

Any model supported by vLLM served from Hugging Face — including Llama, Qwen, Mistral, DeepSeek, Gemma, and vision-language models. We ship curated presets with sensible defaults, and you can point at your own repository; gated weights are pulled with your own access token.

Through an OpenAI-compatible /v1 chat and completions API. Existing SDKs, agent frameworks, and tools work by changing only the base URL — no rewrite. A built-in web chat (and an image-analysis interface for vision models) is included for people who don't want to write code.

Nowhere outside your cloud. Prompts, completions, model weights, and logs stay on operator storage inside your WECORE infrastructure. There are no third-party API calls and no data egress to a model vendor, which makes it a strong fit for sensitive and regulated workloads.

On GPU capacity inside your own WECORE cloud — never on shared vendor hardware. Each model runs as a managed service on a dedicated server, and the endpoint is protected by a per-service API key. You own the GPUs; WECORE runs the serving layer on them.

Yes. Ready dashboards expose tokens/sec, latency, queue depth, and GPU utilization. Because you run on GPUs you already pay for, cost is GPU time — and stopping an idle model stops the cost with it.

Those are general-purpose platforms you build on: KaaS for containerized applications, the HPC platform for Slurm-based batch compute. LLMaaS is a finished product rather than a platform — it serves open models behind a chat UI and an OpenAI-compatible API in one step, so you never assemble the inference stack yourself. You don't need either product to use it.

Early access

Turn your GPUs into a private AI endpoint.

WECORE LLMaaS is for teams that want the convenience of a hosted LLM API without sending prompts and data to a public vendor — open models, an OpenAI-compatible endpoint, and a chat UI, all on infrastructure you control.