serving-llms-vllm

Deploy and optimize vLLM inference servers with OpenAI-compatible endpoints.

Updated May 5, 2026
One-click install
npx skills add https://github.com/yanochka11/harness_bro --skill serving-llms-vllm-yanochka11
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: serving-llms-vllm
Source: https://github.com/yanochka11/harness_bro/tree/main/.claude/skills/ported/serving-llms-vllm
Command: npx skills add https://github.com/yanochka11/harness_bro --skill serving-llms-vllm-yanochka11

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps engineers deploy and optimize large language model serving infrastructure by reducing the complexity of building fast, scalable inference APIs.

Core Features & Use Cases

  • Production LLM Serving: Configure vLLM deployments with OpenAI-compatible endpoints, batching strategies, monitoring, and GPU optimization.
  • Inference Optimization: Tune PagedAttention, continuous batching, prefix caching, speculative decoding, and memory utilization for better latency and throughput.
  • Use Case: Deploy a quantized 70B language model on limited GPU resources while maintaining a production-ready API service with health checks and performance monitoring.

Quick Start

Use the vLLM skill to configure and deploy a high-throughput OpenAI-compatible API server for my language model.

Frequently Asked Questions about serving-llms-vllm

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I deploy a high-throughput LLM inference server with an OpenAI-compatible API?

Deploy high-throughput LLM inference servers using vLLM to configure OpenAI-compatible endpoints with continuous batching and monitoring. This reduces the complexity of building fast, scalable inference APIs for production environments.

Can I serve a quantized 70B language model on limited GPU resources?

Yes, you can serve quantized models on limited GPU resources by applying vLLM inference optimization. This configures memory utilization and continuous batching to maintain a production-ready API service under tight hardware constraints.

What is the best way to optimize GPU memory for large language model serving?

Optimize GPU memory for LLM serving by configuring PagedAttention, prefix caching, and continuous batching via vLLM. These mechanisms improve memory utilization, reducing latency and increasing overall inference throughput.

How does tensor parallelism work for distributed LLM inference?

Tensor parallelism distributes large language model inference workloads across multiple GPUs using vLLM. This distributed inference workflow allows serving models too large for a single GPU while maintaining high-throughput API performance.

Does vLLM support continuous batching and speculative decoding?

Yes, vLLM supports continuous batching and speculative decoding to optimize inference throughput. Tuning these features alongside PagedAttention and prefix caching significantly improves latency and memory utilization for production API serving.

How do I add health checks and performance monitoring to my LLM API?

Add health checks and performance monitoring to LLM APIs by configuring vLLM deployment workflows. This ensures your production-ready OpenAI-compatible endpoint remains observable and facilitates ongoing performance troubleshooting.