vllm

Launches vLLM-based OpenAI-compatible endpoints with PagedAttention and continuous batching.

247|22|Updated Dec 11, 2024
One-click install
npx skills add https://github.com/graniet/kheish --skill vllm-graniet
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: vllm
Source: https://github.com/graniet/kheish/tree/main/skills/mlops/inference/vllm
Command: npx skills add https://github.com/graniet/kheish --skill vllm-graniet

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Standard LLM serving solutions suffer from low throughput, high latency, and inability to fit large models on limited GPU hardware, making production deployment costly and inefficient. This Skill eliminates those bottlenecks by providing vLLM-based serving with optimized memory management and continuous batching.

Core Features & Use Cases

  • Production LLM API Deployment: Launch OpenAI-compatible serving endpoints capable of handling 100+ requests per second with low time-to-first-token latency.
  • Memory-Efficient Large Model Serving: Run 70B+ parameter models on limited GPUs using AWQ, GPTQ, or FP8 quantization without significant accuracy loss.
  • Offline Batch Inference: Efficiently process large datasets of prompts without manual batching overhead for offline use cases.
  • Use Case: A machine learning team can use this Skill to deploy a 70B parameter customer support chatbot on a single 40GB GPU, cutting infrastructure costs by 75% while maintaining sub-500ms response times for end users.

Quick Start

Use the vllm skill to launch a production-ready OpenAI-compatible LLM serving endpoint for your target model with optimized throughput and memory usage.

Frequently Asked Questions about vllm

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

FAQPage Schema
How do I serve large LLM models on limited GPUs without losing accuracy?

Serve large LLM models on limited GPUs using AWQ, GPTQ, or FP8 quantization to reduce memory constraints. This approach allows 70B+ parameter models to run efficiently on a single 40GB GPU without significant accuracy loss.

What is the best way to achieve high throughput for OpenAI-compatible LLM serving?

High throughput for OpenAI-compatible LLM serving is achieved using PagedAttention and continuous batching. This combination maximizes inference performance, enabling endpoints to handle 100+ requests per second with low time-to-first-token latency.

How does PagedAttention optimize memory management for LLM inference?

PagedAttention optimizes LLM inference memory management by implementing continuous batching and paged memory allocation. This mechanism eliminates standard serving bottlenecks, maximizing hardware utilization and reducing time-to-first-token latency.

Can I process large datasets of prompts for offline batch inference without manual batching?

Process large datasets of prompts for offline batch inference without manual batching overhead using continuous batching. This handles large-scale offline inference pipelines efficiently, maximizing hardware utilization throughout processing.

Does vLLM deployment support FP8 quantization for production AI API hosting?

vLLM deployment supports multi-format quantization including FP8, AWQ, and GPTQ for production AI API hosting. This enables memory-efficient large model serving on memory-constrained GPU environments while maintaining OpenAI-compatible endpoints.