Migrate from Azure OpenAI to self-hosted models on vLLM

A practical plan for moving Azure OpenAI deployments to open-weight models on vLLM behind a LiteLLM gateway, covering what moves cleanly, what needs rework and what drives effort.

On this page

How to migrate from Azure OpenAI to self-hosted vLLM without a rushed cutover

A renewal, a provisioned capacity commitment, a model retirement or a residency requirement is usually what forces this decision, and the good news is that the move is an application-level switch to an OpenAI-compatible endpoint plus model replacement and evaluation, not a bulk data export. Prompts, applications and logs stay where they are while you point client code at a vllm serve endpoint, fronted by a gateway such as LiteLLM, and choose an open-weight model that behaves acceptably on your workloads. The platform team usually owns the vLLM and gateway hosting, the security team owns the network path, authentication and logging controls, and the application teams own prompt changes and acceptance tests. Most of the effort and risk sits in model evaluation and day-two operations, not in the API change itself.

Start with an inventory before any hardware is ordered. For each Azure OpenAI deployment, record the model and version, the deployment type (Standard or provisioned), the api-version values your clients send, the token volumes and latency targets, and the retirement or contract date that applies. Then run a replacement candidate set against your own prompts, using the same inputs, expected outputs and scoring rules you already trust, and compare quality, refusal behavior, structured output reliability and cost per successful task. Treat every failing case as a prompt or model decision to record, not a surprise to discover at cutover. Confirm with your Microsoft account team the exact retirement date and whether a provisioned commitment can be shortened or moved, since those terms govern how much parallel running you can afford.

Which Azure OpenAI capabilities map to vLLM and LiteLLM, and which need rework

This table maps each Azure OpenAI capability your applications depend on to its nearest vLLM or LiteLLM equivalent, and marks it clean, needs rework or gap. Read the status column first, then confirm each rework or gap item against your own deployments, identity setup and contract terms before you plan cutover.

CapabilityvLLM and LiteLLM equivalentStatusWhat to confirm
Chat completionsvLLM serves /v1/chat/completions and LiteLLM exposes one OpenAI-compatible endpoint in front of itCleanTest your exact request parameters, tool calling and streaming output against the chosen open-weight model
Completions and responsesvLLM serves /v1/completions and /v1/responses; LiteLLM routes both formatsNeeds reworkCheck which Azure API versions your code pins and whether each feature is present in the vLLM release you run
EmbeddingsvLLM serves /v1/embeddings for a supported embedding modelNeeds reworkEmbedding vectors change when the model changes, so re-index stored vectors before switching
Deployment names and routingLiteLLM model aliases map one application-facing name to one or more backend deploymentsNeeds reworkReplace Azure deployment names in application config and confirm every caller uses the alias
API keys and quotasLiteLLM virtual keys with per-key, per-user and per-team budgets, TPM and RPM limits, and model restrictions; these need a PostgreSQL databaseNeeds reworkRecreate Azure quota assignments as LiteLLM limits and confirm how they map to your capacity
Fallbacks and retriesLiteLLM router offers retries, cooldowns, priority ordering and fallbacks across deploymentsNeeds reworkConfirm failover targets behave consistently, since a fallback to a different model can change outputs
Logging and metricsLiteLLM can log to Langfuse, OpenTelemetry and Prometheus; vLLM exposes Prometheus metrics at /metricsNeeds reworkRebuild dashboards and alerts, and confirm where prompts and completions are stored
Azure content filtersNo direct equivalent in vLLM or LiteLLM by defaultGapConfirm which filtering you need and add guardrails or moderation in your own stack; do not assume parity
Managed identity and Microsoft Entra IDLiteLLM admin UI supports Entra ID SSO; workload identity for service calls is not an Azure managed identityGapConfirm your service authentication design with your identity team and the LiteLLM license tier you need
Provisioned throughput guaranteesThroughput depends on the GPUs you provision and your own capacity planningGapConfirm sizing with load tests on your prompts, since no vendor throughput guarantee applies to self-hosted serving

What moves cleanly and what does not

Application code, prompts and evaluation datasets move with you, but model weights do not. Applications written against the OpenAI request format can point at a vLLM server, which exposes /v1/chat/completions, /v1/completions, /v1/responses and /v1/embeddings, so the main code change is usually the base URL and the model name, routed through a LiteLLM gateway. Your evaluation datasets, prompt templates and test cases are also portable, because they are your own files. Weights, however, cannot be exported from Azure OpenAI. Each open-weight model you run must be sourced from its publisher under that publisher's license, and your legal team should review those terms before any production traffic is planned.

Replacement models behave differently, so every prompt, output parser and guardrail needs revalidation. A different model family, tokenizer or version can change formatting, refusal behavior, tool-call structure and JSON reliability, which can break downstream parsers without any error from the server. Run your existing evaluation set against each candidate on your own prompts, record pass rates per workflow, and pin the exact model revision you approve. Treat this as a gate in the migration plan, not a final check. Confirm with your security and compliance owners whether any content filters or Azure-side safety settings you relied on need an equivalent in your gateway or output checks.

Azure-side logs and stored data do not follow the workload automatically. Any prompt, completion, deployment metadata or audit record you need for investigations, retention obligations or quality history must be exported through Azure's own tools before the resource is decommissioned. Confirm with your Azure administrators which diagnostic settings, log destinations and retention periods are in place, and which data is held under abuse monitoring. Plan the export as its own work item with an owner, a storage location in your environment and a sign-off, because once the deployment is removed, the data may no longer be retrievable by your team.

Which data, keys and integrations to rebuild

A migration off Azure OpenAI moves more than model calls. The prompts, evaluation sets, deployment records, keys and monitoring hooks all have to be rebuilt on your side, because Azure does not hand over model state. Each card below is one component to inventory, rebuild and check before you cut traffic over.

Prompt and evaluation sets

Your prompt templates, system messages, few-shot examples and test cases are the closest thing you have to a specification of the current behavior. Export them from wherever they live today, version them in Git, and tag each case with the deployment it was written against. Without these sets, you cannot tell whether a replacement open-weight model behaves acceptably, so confirm that every production workflow has at least one owner-approved test set before you choose a model.

Deployment and API version inventory

List every Azure OpenAI resource, deployment name, model version, deployment type and the API version each application sends. Record which deployments are Standard, Global or provisioned, because each carries different limits and retirement handling. Map each deployment name to a LiteLLM model alias so application code does not need to change. Confirm retirement dates in your Azure portal, since they are set per model version and are not a fixed cycle you can plan around from memory.

Keys and identities as LiteLLM virtual keys

Azure API keys and Microsoft Entra identities do not carry over to LiteLLM. Replace them with LiteLLM virtual keys, which require a PostgreSQL database and support per-key, per-user and per-team budgets, TPM and RPM limits, and restriction to specific models. Store the master key, which must start with sk-, in a secret manager. Decide which teams get which budgets before you issue keys, and retire each old Azure key only after the new key has passed a test call.

Entra ID sign-in for the admin UI

If your administrators sign in to Azure with Entra ID, LiteLLM's admin UI can use the same identity provider through SSO. Confirm that the SSO free tier covers your administrator count, because it is free for up to 5 users from v1.76.0 and an Enterprise license is needed beyond that. Anything that needs SCIM, audit logs or team RBAC falls under the Enterprise license, so price that before you plan the rollout.

Metrics and tracing hooks

Azure Monitor dashboards, diagnostic logs and alerts will not follow the traffic. Point Prometheus at the LiteLLM proxy and at vLLM's /metrics endpoint so request counts, token throughput, latency and KV cache use are visible from day one. If you already use Langfuse, configure LiteLLM's logging callback to send traces there. Rebuild each alert you rely on today, and confirm which trace fields your evaluation process needs before you switch.

Migration sequence from inventory to decommission

This sequence moves Azure OpenAI workloads to open-weight models on vLLM behind a LiteLLM gateway, one consumer at a time, and ends with Azure deployments removed before their contract or retirement date. Each step produces a record that the next step depends on.

  1. Inventory deployments, API versions and consumers

    The platform team, with each application owner, lists every Azure OpenAI resource, deployment name, model and version, deployment type (Standard, provisioned or Batch), region, API version and key or identity method in use. For each deployment, record which applications, scripts, evaluation jobs and third-party tools call it, along with request volume, token profile and any data handling obligations. Confirm contract terms, provisioned capacity commitments and the retirement date for each model with your Microsoft account team and the Azure OpenAI model retirement documentation. The step is done when every consumer maps to a deployment and every deployment has an owner, a retirement or contract date and a documented API version.

  2. Stand up vLLM and a LiteLLM gateway

    Infrastructure engineers deploy vLLM on GPU capacity in your own cloud subscription, data center or private network, using the Kubernetes option that fits your platform. Place vLLM behind a reverse proxy that allowlists only the endpoints applications need, because the vLLM API key does not protect every route. Deploy the LiteLLM AI Gateway pointing at the vLLM endpoints, with PostgreSQL for virtual keys and spend tracking. Once more than one proxy instance runs, add Redis 7.0 or newer for shared rate limits and router state. Store the master key in a secret manager. The step is done when a test client sends an OpenAI-format request through the gateway to vLLM and receives a response, and the metrics for both components appear in your monitoring stack.

  3. Evaluate candidate open-weight models on your own prompts

    The application owners and a quality or evaluation lead build a test set from anonymized production-like prompts, expected outputs and the criteria that matter for each use case, such as accuracy, format compliance, refusal behavior and latency. Run the same set against the current Azure deployment and each candidate open-weight model served on vLLM, using the same parameters where the APIs allow it. Record the results, failure cases and the serving configuration for each model, including the exact model version and vLLM release. Public benchmarks are a starting point only. The step is done when each use case has a signed-off model choice, a pinned model version and a documented set of known differences from the Azure output.

  4. Run both paths in parallel with routing and fallbacks

    Configure LiteLLM model groups so each application alias can route to either the Azure deployment or the vLLM model, using the routing strategy and priority ordering suited to the workload. Keep the Azure path as a fallback for the migration window, and set retries and cooldowns so repeated vLLM failures move traffic without manual action. Enable logging to your observability stack, and compare cost, latency, error rates and output quality between the two paths on live traffic in a controlled subset. Confirm with the security team that prompts and completions on the self-hosted path stay where your data rules require. The step is done when both paths serve traffic, failover has been tested by forcing a failure, and the comparison data supports moving each consumer.

  5. Cut over by consumer and decommission Azure deployments

    Move consumers one at a time, starting with the lowest-risk workloads, by changing their alias or base URL to the gateway and removing the Azure route once the comparison holds. Revoke Azure keys and disable deployments as each consumer moves, and keep the inventory from step one current. Before the contract end or model retirement date, shift remaining traffic, confirm no consumer still calls the Azure endpoint through logs, and delete or disable the deployments. Retain the evaluation records, configuration and change history as evidence for your compliance and audit teams, who decide what they need. The step is done when the inventory shows zero active Azure consumers, the Azure resources are removed or disabled, and the decommission record is filed.

Running Azure OpenAI and vLLM side by side

Run both paths at once and move traffic in steps, so Azure OpenAI stays in service until your own evaluation results hold. In LiteLLM, define the vLLM deployment and the existing Azure deployment under the same model group, then use priority ordering so Azure serves as the failover target. Start with a small share of traffic on vLLM using simple-shuffle routing, which LiteLLM recommends as its default, and compare error rates, latency and evaluation scores per route before raising that share. Latency-based routing can help once both backends have been measured under real load, but confirm its behavior with your own traffic before relying on it. Keep the Azure deployment, its keys and its fallback entry in place until the cutover criteria you agreed with the evaluation team have been met for a sustained period, and record the date you remove it so the decision is auditable.

The vLLM server needs its own protection before any application traffic reaches it. The --api-key option does not cover every endpoint: according to the vLLM security documentation, it protects the /v1, /v2, /inference and /cohere paths but not /metrics, /health, /pause, /resume, /abort_requests or /invocations. Put a reverse proxy in front of the server and allowlist only the endpoints your applications call, and block the administrative and metrics paths from the application network. If you run a multi-node deployment, the same documentation states that traffic between nodes is insecure by default, with no authorization or encryption, so place the nodes on an isolated network and confirm that Ray or the multiprocessing backend cannot be reached from outside it. Treat these as acceptance tests in your migration plan, not as settings you assume are present.

vLLM ships new minor releases roughly every two weeks, so a deployment that tracks the latest tag will change behavior often. Before the first production route goes live, choose one vLLM release, pin the container image or package version, and test the same evaluation suite against it. Ask your platform team to confirm which release your GPU driver, CUDA or ROCm stack and model architecture support, and schedule upgrades as deliberate revalidation events with their own evaluation run and rollback plan. Pinning also gives you a stable reference when comparing results against Azure, where model versions have their own retirement dates.

How the migration changes by starting point

A single application on pay-per-token Standard deployments usually has one endpoint, one key and a short list of models, so the work centers on showing that a replacement open-weight model handles your prompts well enough before the application switches. Put a LiteLLM gateway in front of the application first, so the code calls one OpenAI-compatible URL and the model behind it can change later. Then serve the candidate model on vLLM and run the same prompt set against both endpoints.

  • Gateway first: Point the application at LiteLLM while it still routes to Azure OpenAI, so the eventual switch is a configuration change.
  • Evaluation set: Build test cases from production prompts with personal data removed, and score outputs for the tasks the application actually performs.
  • Endpoint exposure: Place a reverse proxy in front of vLLM that allows only the routes the gateway needs, because the --api-key option does not cover every route.
  • Controlled cutover: Shift a small share of traffic, watch errors and latency through the /metrics endpoint, and keep a tested path back to Azure OpenAI until the new route has run cleanly.

Confirm with the application owner which OpenAI API features the application uses, such as tool calling, structured outputs or streaming, and check that the vLLM version you deploy supports each one.

What drives migration cost and duration

This table lists the factors that set the effort of moving Azure OpenAI workloads to self-hosted vLLM, with what each one means and how to reduce it. No figures are given because none are supplied for this comparison, so use the rows to scope your own inventory and ask vendors and implementers for estimates based on your counts.

DriverWhy it moves cost or effortHow to keep it down
Deployments and API versionsEach Azure OpenAI deployment maps to a model, version, region and quota setting that must be recreated or replaced. Pinned API versions in client code add change work.Export a full inventory of deployments, model versions, API versions and quotas first, then group identical configurations so they migrate once.
Consuming applicationsEvery application, batch job and internal script that calls the endpoint needs a base URL, key and model name change, plus regression testing.Route all calls through one LiteLLM gateway so applications switch by model alias rather than by code change.
Prompt and output dependence on model behaviorPrompts tuned to one model's quirks, structured output formats and tool-calling behavior often need rewriting when the model changes.Identify which workloads depend on exact output format or tool calls, and prioritize those for prompt and schema hardening before cutover.
Evaluation dataset qualityWithout representative test cases drawn from your own traffic, comparing replacement models is slow and disputed. Gaps here extend every other phase.Build a labeled set from real, de-identified production prompts with agreed pass criteria, and reuse it across candidate models.
GPU capacity and procurement lead timeAccelerator hardware, data center space and power are paid for whether or not they are used. Lead times can set the schedule more than engineering does.Size from measured token volumes and concurrency, confirm hardware delivery dates with suppliers early, and check whether reserved cloud GPUs can cover the gap.
Number of vLLM nodes and multi-node networkingModels too large for one node need tensor and pipeline parallelism across machines. vLLM notes that inter-node traffic is unauthenticated and unencrypted by default, so isolated networking and extra hardening add work.Keep to a single node where the model fits, and if you span nodes, plan an isolated network segment before deployment.
Identity integrationAccess to the gateway and admin UI must map to your identity provider, and per-team virtual keys need an owner process. SSO beyond the free user limit requires a LiteLLM Enterprise license.Confirm which identity provider you use, decide key ownership and budgets up front, and ask whether the license tier covers your user count.
Observability build-outMetrics, logs and traces must be collected and retained to replace what Azure provided, and the stack (for example Prometheus and Langfuse) adds components to operate.Reuse existing Prometheus and OpenTelemetry tooling where possible, and define the dashboards and alerts needed for cutover before migration starts.

What usually goes wrong and how to prevent it

Most failed migrations from Azure OpenAI to self-hosted vLLM trace back to a few predictable gaps: untested models, exposed endpoints, unsecured internal traffic, a gateway that cannot scale, deadlines that pass without a fallback, and upgrades nobody pinned. Each risk below has one prevention step you can check before cutover.

Cutting over before model evaluation

Teams often switch the base URL once a model answers test prompts, then discover weaker answers on real traffic. Replacement models differ in tone, JSON reliability, tool calling and refusal behavior, so a model that passes a demo can fail your production prompts. Run your own prompt set against the candidate model and the current Azure OpenAI deployment, and sign off on scored results before routing any production traffic.

Exposing non-user endpoints

The vLLM --api-key option protects endpoints under /v1, /v2, /inference and /cohere, but not /invocations, /pause, /resume, /abort_requests, /metrics or /health. A team that relies on the key alone can leave operational endpoints reachable from applications or the network. Place a reverse proxy in front of vLLM that allowlists only the endpoints users need and confirm from outside the cluster that the others return denied.

Unprotected inter-node traffic

In multi-node deployments, vLLM communication between nodes is insecure by default, with no authorization or encryption. Tensor and pipeline parallelism across machines makes that traffic part of your model serving path, so an open network segment exposes it. Place all vLLM nodes on an isolated network segment and verify with your platform team that no other workloads or user networks can reach the inter-node ports.

Running several proxies without Redis

LiteLLM uses PostgreSQL as its primary database, and once more than one proxy instance runs, it needs Redis 7.0 or newer for shared rate limits, router state and cache. Without it, each proxy enforces budgets and rate limits on its own view, so keys can exceed their limits and failover state diverges. Provision Redis 7.0 or newer before adding a second proxy replica and test a limit against two replicas before go-live.

A retirement date passes with no rollback

Provisioned Azure OpenAI deployments must be migrated by hand when a model retires, and retirement dates cannot be extended. If the self-hosted path is not ready by that date, production traffic can fail outright. Keep the Azure OpenAI deployment reachable through the same LiteLLM model name until the self-hosted route has passed evaluation and run in production, and record the retirement date in your change calendar.

Unversioned vLLM upgrades

vLLM ships new minor releases about every two weeks, and behavior such as default settings, output formatting or API handling can change between them. An upgrade applied without a test run can alter answers in production with no code change on your side. Pin the vLLM image to a specific release tag, rerun your evaluation set before each upgrade, and promote the new version only after it passes.

Questions buyers ask before moving off Azure OpenAI

How much does it cost to move off Azure OpenAI to vLLM?

vLLM itself has no license fee, so the cost comes from four components: accelerator capacity (GPUs or other accelerators), the surrounding infrastructure such as storage, networking and the gateway, implementation work, and the engineers who operate the stack. Accelerator capacity is usually the largest recurring line and is paid to your cloud provider or data center whether the GPUs are busy or idle. Implementation is largely one-time. Your current Azure OpenAI spend is pay-per-token, reserved provisioned throughput or a mix, and the break-even point depends on how steadily your workloads use capacity. Ask for a quote built from a written scope, and compare it against your own Azure invoices for the last several months and your contract terms, which you should confirm directly with Microsoft.

How long does a migration off Azure OpenAI take?

The timeline depends on how many deployments you run, how many applications call them, how much prompt evaluation you need, and when your provisioned or retirement dates fall. The work runs in stages: inventory deployments and API versions, stand up vLLM behind a LiteLLM gateway, evaluate candidate open-weight models on your own prompts, then move workloads one group at a time. Hardware procurement or capacity approval is often the longest lead item in your own environment. Before you commit to a date, confirm your retirement and provisioned-deployment dates with your Azure account team, because those dates set the deadline and cannot be extended by the customer.

What does our team need to provide for this migration?

You need a named technical owner, access to your Azure OpenAI deployments and their logs, a cloud or data center environment where GPU instances can run, and people who can review evaluation results against your business requirements. Security and compliance staff should review network placement, authentication, and how the gateway's keys and secrets are stored. Application owners must confirm which prompts and outputs matter for their use case, since only they can judge whether a replacement model is good enough. Your team will also need an on-call path for the inference stack, because self-hosting moves operational responsibility from Microsoft to you.

Can our own team run a vLLM migration without outside help?

Teams with experience in Kubernetes or GPU infrastructure, Python-based services and production on-call can often do much of the work in-house, especially the gateway configuration and application changes. The harder parts are sizing GPU capacity, setting up secure networking between nodes, hardening the endpoints, building evaluation and monitoring, and defining the upgrade process for a project that ships new minor releases about every two weeks. A fixed-scope engagement with DeployOpen can cover planning, implementation, hardening, backup and documentation inside your own infrastructure, and ongoing support is available as a retainer. Your decision should rest on the skills you have today and the staffing you can commit over time.

Does migrating off Azure OpenAI export our data from Azure?

Migration itself does not require moving your prompts or completions out of Azure, but you should plan for the data you need to carry over. Typical items are your prompt templates, system messages, evaluation datasets, fine-tuning data if you have any, and logs you want to keep for audits. Confirm with Microsoft what retention, deletion and export options apply to your Azure OpenAI resources and any stored data, since those terms are set in your contract and service documentation. Once workloads run on vLLM, prompts and outputs stay in the environment you control, and you decide where they are logged and how long they are kept.

Will our applications need code changes after the switch?

In most cases, the change is limited to configuration. The vLLM server exposes OpenAI-compatible endpoints, including chat completions, completions, responses and embeddings, so applications written for the OpenAI API can point at a new base URL. The LiteLLM gateway gives those applications one OpenAI-compatible endpoint in front of vLLM, which lets you route, limit and log traffic without changing client code each time a model changes. Check each application for Azure-specific details such as deployment names, api-version parameters, Azure AD authentication and any features that depend on a particular model, and test those paths before cutover. Model behavior will still differ, so output checks are required.

How do we keep the new endpoint from being exposed to everyone?

The vLLM --api-key option protects the /v1 endpoints, but the vLLM security documentation says not to rely on it alone. It does not cover endpoints such as /metrics, /health or /pause, so the recommended approach is a reverse proxy that allowlists only the endpoints meant for users, placed in a network that clients can reach. Multi-node deployments also need isolated networking because inter-node traffic is insecure by default. On the gateway side, LiteLLM virtual keys with budgets, rate limits and model restrictions limit what each team or application can do, and its master key should live in a secret manager. Have your security team review this design before any production traffic moves.

Which open-weight models should we test before cutover?

Choose candidates based on your own prompts, not on public leaderboards. Start by listing the tasks each Azure OpenAI deployment performs, such as classification, summarization, extraction or code assistance, and build an evaluation set from anonymized production-like examples. Run each candidate model through the same set, measure quality, latency and throughput on your hardware, and record the results with the exact model version and vLLM release used. Also check licenses for each model, since open-weight licenses vary, and confirm which model features your applications rely on, such as tool calling or structured output. Keep a fallback path to Azure OpenAI until the evaluation signs off.

What to confirm before you request a quote

Before asking for a quote, build a complete inventory of every Azure OpenAI deployment in scope: the deployment name, the underlying model and version, the deployment type (Standard, Global, Data Zone or provisioned), the api-version strings your applications send, and the rate or capacity each deployment carries. Pair that inventory with the contract terms from your Azure agreement, including any provisioned throughput commitment and the retirement date Microsoft has published for each model version. Ask your account team to confirm those dates in writing, because they determine how much time the migration has and which deployments must move first. Also list every consumer: applications, internal tools, batch jobs, evaluation pipelines and third-party products that call the endpoint, along with the owner of each. Missing consumers are the most common source of cutover surprises.

Next, document the residency and logging requirements that the replacement must meet. Confirm which data classes flow through the prompts and completions, where they may be processed, how long request and response content may be retained, and whether your security team needs prompt logging for incident response or must avoid it entirely. These answers decide where the vLLM servers and the LiteLLM gateway run, which log sinks such as Langfuse or Opik receive payloads, and whether the /metrics endpoint or request bodies may leave your network. Record who approves each answer, since a quote should reflect those controls rather than assumptions. Finally, confirm the accelerator side with your infrastructure team before the quote is scoped. Check the vLLM installation documentation against the GPU vendor and driver stack you can actually buy or already operate, and confirm the lead times and export or procurement rules that apply to your region. Verify whether your environment needs a LiteLLM Enterprise license for SSO beyond the free user limit, audit logs, SCIM or secret manager integration, and confirm the current edition terms on the LiteLLM enterprise documentation. Those answers change both the licensing line and the implementation effort.

How DeployOpen scopes and runs the migration

DeployOpen plans, implements, hardens, documents and supports self-hosted open-source platforms inside your own infrastructure, so the vLLM serving stack, the LiteLLM gateway and the evaluation work for this migration run in your cloud account, data center or network. Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.

How we scope

  • We inventory your Azure OpenAI deployments, model versions, API versions and provisioned capacity before agreeing any scope.
  • The written scope names which workloads move, which replacement open-weight models are tested and which applications switch endpoints.
  • We confirm the hosting location, GPU capacity, identity provider and logging targets your environment requires before work starts.
  • Quotes follow from the written scope, and ongoing support or upgrades can be added as a retainer.

How we build

  • We deploy vLLM with its OpenAI-compatible server and place a LiteLLM gateway in front of it, configured with virtual keys and budgets.
  • We run replacement model candidates against your own prompts and evaluation sets, and record quality, latency and cost results.
  • We place vLLM behind a reverse proxy that allowlists only the endpoints meant for users, and secure node-to-node traffic on multi-node runs.
  • We connect metrics, traces and logs to your existing monitoring stack and test failover and rate limits before cutover.

How we hand over

  • Handover documents cover architecture, configuration, model versions, the cutover runbook and rollback steps for each migrated workload.
  • We provide the evidence your assessors may ask for, such as access control settings, logging configuration and evaluation records, without issuing any audit report.
  • Your team receives a written upgrade procedure for vLLM and LiteLLM releases, including how model pins change and how regressions are re-tested.
  • Staff training covers day-to-day operation, on-call escalation and the criteria for adding or retiring a model.

How we support

  • Ongoing support, version upgrades and continuous testing of the serving stack are available as retainers after handover.
  • Retainers can cover periodic revalidation of pinned models against new prompts, so model changes stay under your control.
  • Security testing of the gateway and API endpoints can be scoped separately, including AI and agent security checks.
  • Ask us to confirm which vLLM and LiteLLM releases your retainer covers and how security patches are applied.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.