企业官网建设流程全解析

SGLang Runtime 示例全解：从 Native API 到离线引擎的多场景推理实战

【免费下载链接】sglangSGLang is a high-performance serving framework for large language models and multimodal models.项目地址: https://gitcode.com/GitHub_Trending/sg/sglang

本指南以 SGLang 仓库中的 examples/runtime 目录为主线，系统梳理 SGLang 运行时（Runtime）的各类官方示例：OpenAI 兼容 Native API 下的 LoRA 微调适配、响应预填充（response prefill）、奖励模型打分与 Chain-of-Verification 幻觉抑制，以及不依赖 HTTP 服务的离线 Engine API、Hidden States 提取、多模态推理和 Token-In-Token-Out 工作流。读完本文，你将掌握如何在两个终端中分别启动 SGLang 服务端与运行客户端脚本，并能按需组合 Engine API 打造自定义服务。

使用前须知：一切示例都基于"服务端 + 客户端"双终端模式

examples/runtime下的绝大多数示例遵循同一套运行范式：先在一个终端启动 SGLang 服务端，再在另一个终端运行示例脚本。README 明确指出 "The below examples will mostly need you to start a server in a separate terminal before you can execute them. Please see in the code for detailed instruction."（大多数示例需要你先在单独的终端中启动服务器，详细指令请参见代码中的注释）。

每个脚本的 docstring 头部都写明了对应的服务端启动命令，例如：

# 以 LoRA 示例为例（见 examples/runtime/lora.py） python -m sglang.launch_server \ --model meta-llama/Llama-3.1-8B-Instruct \ --enable-lora \ --lora-paths sql=/path/to/sql python=/path/to/python

服务端默认监听http://127.0.0.1:30000，客户端脚本通过 OpenAI SDK（openai.Client(base_url="http://127.0.0.1:30000/v1")）或直接requests.post访问/v1、/generate、/classify、/vertex_generate等路由。

而engine子目录下的示例则属于离线引擎模式，不经过 HTTP，直接在 Python 进程内构造sgl.Engine完成推理，特别适合批处理、离线评测与构建自定义服务。

Native API：OpenAI 兼容接口下的七类典型用法

1. LoRA 适配器：模型参数中的adapter:name语法

examples/runtime/lora.py 演示了在 OpenAI 兼容接口下使用 LoRA 适配器的完整流程。启动服务端时需额外传入两个参数：

• --enable-lora：开启 LoRA 支持；
• --lora-paths sql=/path/to/sql python=/path/to/python：以名称=路径的键值对形式注册适配器。

脚本覆盖四种请求形态：

import openai client = openai.Client(base_url="http://127.0.0.1:30000/v1", api_key="EMPTY") # 1. Chat Completions：通过 model 参数中的 adapter:name 语法指定适配器 response = client.chat.completions.create( model="meta-llama/Llama-3.1-8B-Instruct:sql", # ← adapter:name 语法 messages=[{"role": "user", "content": "Convert to SQL: show all users"}], max_tokens=50, ) # 2. Completions API 同样支持适配器 response = client.completions.create( model="meta-llama/Llama-3.1-8B-Instruct:python", prompt="def fibonacci(n):", max_tokens=50, ) # 3. 向后兼容：通过 extra_body 显式传入 lora_path response = client.chat.completions.create( model="meta-llama/Llama-3.1-8B-Instruct", messages=[{"role": "user", "content": "Convert to SQL: show all users"}], extra_body={"lora_path": "sql"}, max_tokens=50, ) # 4. 不携带任何适配器，使用基础模型 response = client.chat.completions.create( model="meta-llama/Llama-3.1-8B-Instruct", messages=[{"role": "user", "content": "Hello!"}], max_tokens=30, )

其中model="base_model:adapter_name"的adapter:name语法是推荐的新式写法，而extra_body={"lora_path": "sql"}是向后兼容的旧式写法。若服务端未启动，脚本会捕获异常并提示检查python -m sglang.launch_server --model ... --enable-lora --lora-paths ...。

2. 多模态 Embedding：/v1/embeddings路由

examples/runtime/multimodal_embedding.py 演示了多模态嵌入提取。服务端以嵌入模式启动：

python -m sglang.launch_server --model-path Alibaba-NLP/gme-Qwen2-VL-2B-Instruct --is-embedding

客户端通过原生 HTTP 构造input数组，其中可混合文本与图片（图片既支持 URL 也支持 base64 编码）：

import requests url = "http://127.0.0.1:30000" text_input = "Represent this image in embedding space." image_path = "https://huggingface.co/datasets/liuhaotian/llava-bench-in-the-wild/resolve/main/images/023.jpg" payload = { "model": "gme-qwen2-vl", "input": [{"text": text_input}, {"image": image_path}], } response = requests.post(url + "/v1/embeddings", json=payload).json() print("Embeddings:", [x.get("embedding") for x in response.get("data", [])])

这里的input列表即 OpenAI Embeddings API 的扩展形态：每个元素用text或image字段区分模态。与离线引擎版的 examples/runtime/engine/embedding.py 相比（后者通过sgl.Engine(model_path=..., is_embedding=True)和llm.encode(prompts)实现），网络版更适合部署后由外部服务调用。

3. 批量请求：Chat 与 Completions

README 中还列有openai_batch_chat.py与openai_batch_complete.py两个示例，分别演示如何用 OpenAI 兼容接口批量处理 Chat Completion 与文本 Completion 请求。两者均可借助 OpenAI SDK 在一个客户端会话中连续提交多条请求，由 SGLang 服务端统一调度批处理，是压测与批量评测的常用起点。

4. 响应预填充：continue_final_message参数

examples/runtime/openai_chat_with_response_prefill.py 是 README 中重点加粗介绍的示例，演示了 Anthropic 风格的 "prefill Claude's response" 技巧在 SGLang 中的实现：启用continue_final_message后，对话中最后一条（不完整的）assistant 消息会被移除，其内容作为 prefill 喂给模型，使模型"续写"这条消息而不是开启全新一轮。

启动服务端后（python -m sglang.launch_server --model-path meta-llama/Llama-3.1-8B-Instruct --port 30000），运行脚本即可看到两种行为的对比：

import openai client = openai.Client(base_url="http://127.0.0.1:30000/v1", api_key="EMPTY") messages = [ {"role": "system", "content": "You are a helpful AI assistant."}, { "role": "user", "content": """ Extract the name, size, price, and color from this product description as a JSON object: <description> The SmartHome Mini is a compact smart home assistant available in black or white for only $49.99. At just 5 inches wide, it lets you control lights, thermostats, and other connected devices via voice or app— no matter where you place it in your home. This affordable little hub brings convenient hands-free control to your smart devices. </description> """, }, {"role": "assistant", "content": "{\n"}, # 预填充的 JSON 开头 ] # 启用 continue_final_message：assistant 消息被移除，{"\n" 作为 prefill，模型续写 JSON response_with = client.chat.completions.create( model="meta-llama/Llama-3.1-8B-Instruct", messages=messages, temperature=0, extra_body={"continue_final_message": True}, ) print(response_with.choices[0].message.content) # 不启用：保持默认行为，模型会将其当作历史消息开启新的一轮 response_without = client.chat.completions.create( model="meta-llama/Llama-3.1-8B-Instruct", messages=messages, temperature=0, ) print(response_without.choices[0].message.content)

该能力对结构化输出（如强制 JSON 抽取）尤其有用：先由调用方写好{\n这类前缀，让模型沿着既定格式续写，显著提升格式命中率。

5. 奖励模型打分：/classify路由

examples/runtime/reward_model.py 演示如何从奖励模型（reward model）中提取分数，用于 RLHF 数据筛选等场景。服务端同样以嵌入模式启动：

python -m sglang.launch_server --model LxzGordon/URM-LLaMa-3.1-8B --is-embedding

客户端向/classify路由提交conv字段——一个由多轮对话（user/assistant 对）组成的列表，服务端为每段对话返回一个标量分数：

import requests url = "http://127.0.0.1:30000" PROMPT = "What is the range of the numeric output of a sigmoid node in a neural network?" RESPONSE1 = "The output of a sigmoid node is bounded between -1 and 1." RESPONSE2 = "The output of a sigmoid node is bounded between 0 and 1." json_data = { "conv": [ [{"role": "user", "content": PROMPT}, {"role": "assistant", "content": RESPONSE1}], [{"role": "user", "content": PROMPT}, {"role": "assistant", "content": RESPONSE2}], ], } response = requests.post(url + "/classify", json=json_data).json() print("scores:", [x["embedding"] for x in response])

返回结果中embedding字段承载奖励分数，脚本会打印出两个候选回答各自的得分，便于直观对比优劣（上例中回答 2 才是正确的）。

6. Vertex AI 在线预测：/vertex_generate路由

examples/runtime/vertex_predict.py 展示了 Google Cloud Vertex AI Online Predictions 预测路由的请求/响应格式。它既可以在本地验证请求格式，也提供了部署到 Vertex AI 后的 Python SDK 调用方式：

# 本地验证：模拟 Vertex 的 instances/parameters 请求结构 import requests class LocalVertexEndpoint: def __init__(self) -> None: self.base_url = "http://127.0.0.1:30000" def predict(self, instances, parameters=None): response = requests.post( self.base_url + "/vertex_generate", json={"instances": instances, "parameters": parameters}, ) return VertexPrediction(predictions=response.json()["predictions"]) # 单条提示词 response = endpoint.predict(instances=[{"text": "The capital of France is"}]) # 多条提示词 + 采样参数 response = endpoint.predict( instances=[ {"text": "The capital of France is"}, {"text": "What is a car?"}, ], parameters={"sampling_params": {"max_new_tokens": 16}}, )

脚本 docstring 同时给出了部署到 Vertex AI Endpoint 后通过 Python SDK 发送请求的写法：

response = endpoint.predict( instances=[{"text": "The capital of France is"}, {"text": "What is a car?"}], parameters={"sampling_params": {"max_new_tokens": 16}}, ) print(response.predictions)

本地路由的关键在于把 SGLang 请求包装成 Vertex AI 的instances+parameters双层结构，parameters.sampling_params内嵌 SGLang 采样参数，实现从本地到云端的请求格式无缝迁移。

7. Chain-of-Verification（CoVe）：用隔离会话抑制幻觉

examples/runtime/chain_of_verification.py 实现了 Dhuliawala et al. (2023) 论文《Chain-of-Verification Reduces Hallucination in Large Language Models》中的Factored CoVe模式。其核心思想是：验证环节在一个全新的、隔离的会话中执行，不共享原始回答的任何历史与 KV-cache，从而避免模型只是机械复述自己（可能幻觉）的回答，而是真正去核查。这也正是 README 强调的 "fresh, isolated session (no shared KV-cache) to avoid self-confirmation bias"。

完整流程分为四步：

脚本提供完整的命令行参数：--base-url（默认http://127.0.0.1:30000/v1）、--model（缺省时自动从/v1/models探测）、--prompt、--max-tokens、--temperature、--summarize、--quiet。例如：

python chain_of_verification.py --prompt "What year did the Titanic sink?" python chain_of_verification.py \ --base-url http://127.0.0.1:30002/v1 \ --model moonshot-v1-8k \ --prompt "Who invented the telephone?"

实现上的一个细节值得注意：脚本在提取模型输出时会同时检查content与reasoning_content字段——推理模型（如 Kimi-K2.5、Qwen3）在temperature=0等配置下可能把正文放在reasoning_content中而content为空，因此做了回退兜底。验证用的系统提示词为：

VERIFY_SYSTEM_PROMPT = ( "You are a strict fact-checker. " "You will be given a user question and a candidate answer. " "Decide whether the answer is accurate and directly addresses the question. " "Reply with exactly one of: PASS or FAIL, followed by a brief reason." )

判定逻辑是verdict.strip().upper().startswith("PASS")，即模型回复以PASS开头即视为通过验证，否则进入修正环节。

Engine 子目录：离线引擎 API 全家桶

examples/runtime/engine目录汇集了 Offline Engine API 的常见工作流示例，对应的目录级说明文档为 examples/runtime/engine/readme.md。它的最大优势是无需 HTTP 服务器，在进程内直接完成推理，同时引擎会自动调度大批量请求以避免 OOM。

启动引擎：launch_engine.py与必须的__main__守卫

最精简的引擎示例 examples/runtime/engine/launch_engine.py：

import sglang as sgl def main(): llm = sgl.Engine(model_path="meta-llama/Meta-Llama-3.1-8B-Instruct") llm.generate("What is the capital of France?") llm.shutdown() # 必须保留 __main__ 守卫！ if __name__ == "__main__": main()

代码注释明确解释了__main__条件的必要性：SGLang 引擎使用spawn方式创建子进程，spawn 每次都会启动一个全新的 Python 解释器；如果缺少该守卫，sgl.Engine会陷入无限循环地不断派生子进程。所有 Engine 示例（含下方离线批处理、embedding、EAGLE、VLM 等）都必须遵循这一约定。

离线批处理：offline_batch_inference.py

examples/runtime/engine/offline_batch_inference.py 是批处理的标准模板：通过ServerArgs.add_cli_args(parser)注入全部服务端命令行参数，再以dataclasses.asdict(server_args)展开传给sgl.Engine：

import argparse import dataclasses import sglang as sgl from sglang.srt.server_args import ServerArgs def main(server_args: ServerArgs): prompts = [ "Hello, my name is", "The president of the United States is", "The capital of France is", "The future of AI is", ] sampling_params = {"temperature": 0.8, "top_p": 0.95} llm = sgl.Engine(**dataclasses.asdict(server_args)) outputs = llm.generate(prompts, sampling_params) for prompt, output in zip(prompts, outputs): print("===============================") print(f"Prompt: {prompt}\nGenerated text: {output['text']}") if __name__ == "__main__": parser = argparse.ArgumentParser() ServerArgs.add_cli_args(parser) args = parser.parse_args() server_args = ServerArgs.from_cli_args(args) main(server_args)

运行方式：python3 offline_batch_inference.py --model meta-llama/Llama-3.1-8B-Instruct。当输入批次非常大时，引擎会智能调度请求、高效处理并防止 OOM——这是离线引擎区别于逐个请求的关键收益。

Embedding 生成

examples/runtime/engine/embedding.py 展示了嵌入生成：sgl.Engine(model_path="Alibaba-NLP/gte-Qwen2-1.5B-instruct", is_embedding=True)，随后调用llm.encode(prompts)，返回结果中的embedding字段即嵌入向量。与前面 Native API 的/v1/embeddings相比，这里完全在进程内完成。

EAGLE 投机解码

examples/runtime/engine/offline_batch_inference_eagle.py 演示了基于 EAGLE 的投机解码（speculative decoding）。只需在构造 Engine 时指定一组投机解码参数：

llm = sgl.Engine( model_path="meta-llama/Llama-2-7b-chat-hf", speculative_algorithm="EAGLE", speculative_draft_model_path="lmsys/sglang-EAGLE-llama2-chat-7B", speculative_num_steps=3, speculative_eagle_topk=4, speculative_num_draft_tokens=16, cuda_graph_max_bs_decode=8, ) outputs = llm.generate(prompts, sampling_params)

核心参数含义：speculative_algorithm指定算法（此处为 EAGLE）；speculative_draft_model_path指向草稿模型；speculative_num_steps为每轮推测步数；speculative_eagle_topk为 EAGLE 每步保留的候选 token 数；speculative_num_draft_tokens控制草稿 token 总量；cuda_graph_max_bs_decode限定解码阶段 CUDA Graph 的最大批大小。

VLM 推理

examples/runtime/engine/offline_batch_inference_vlm.py 演示多模态模型离线推理。关键点是：先从sglang.srt.parser.conversation的chat_templates中按chat_template参数取出对话模板，用其image_token在提示词中占位，再通过image_data传入图片 URL：

conv = chat_templates[server_args.chat_template].copy() image_token = conv.image_token image_url = "https://github.com/sgl-project/sglang/blob/main/examples/assets/example_image.png?raw=true" prompt = f"What's in this image?\n{image_token}" output = vlm.generate( prompt=prompt, image_data=image_url, sampling_params={"temperature": 0.001, "max_new_tokens": 30}, )

运行：python offline_batch_inference_vlm.py --model-path Qwen/Qwen2-VL-7B-Instruct。

异步生成：offline_batch_inference_async.py

examples/runtime/engine/offline_batch_inference_async.py 展示异步生成用法（engine.async_generate），适用于在批处理框架上实现"在线式"请求：既保留批量推理的吞吐，又能以异步方式逐条响应。

基于 Sanic 的自定义服务器：custom_server.py

examples/runtime/engine/custom_server.py 演示如何在 SGLang Engine 之上用 Sanic 搭建自定义服务，同时提供非流式与流式两个端点。安装与运行步骤：

pip install sanic python custom_server # 仓库中实际运行命令为 python custom_server.py

curl -X POST http://localhost:8000/generate -H "Content-Type: application/json" -d '{"prompt": "The Transformer architecture is..."}' curl -X POST http://localhost:8000/generate_stream -H "Content-Type: application/json" -d '{"prompt": "The Transformer architecture is..."}' --no-buffer

服务端实现的核心模式是复用引擎的异步接口：

from sanic import Sanic, text, json import sglang as sgl engine = None app = Sanic("sanic-server") @app.route("/generate", methods=["POST"]) async def generate(request): prompt = request.json.get("prompt") result = await engine.async_generate(prompt) # async_generate 返回 dict return text(result["text"]) @app.route("/generate_stream", methods=["POST"]) async def generate_stream(request): prompt = request.json.get("prompt") result = await engine.async_generate(prompt, stream=True) response = await request.respond() async for chunk in result: # 流式结果是 async generator await response.send(chunk["text"]) await response.eof() def run_server(): global engine engine = sgl.Engine(model_path="meta-llama/Meta-Llama-3.1-8B-Instruct") app.run(host="0.0.0.0", port=8000, single_process=True)

可见sgl.Engine.async_generate是构建自定义 Web 服务的统一异步入口：非流式时返回 dict，流式时返回 async generator。

基于 FastAPI 的服务：fastapi_engine_inference.py

examples/runtime/engine/fastapi_engine_inference.py 展示如何用 FastAPI 的 lifespan 机制管理引擎生命周期。服务启动时初始化sgl.Engine，请求通过engine.async_generate处理，并支持MODEL_PATH/TP_SIZE环境变量配置：

python fastapi_engine_inference.py --model-path Qwen/Qwen2.5-0.5B-Instruct --tp_size 1 --host 127.0.0.1 --port 8000 [--startup-timeout 60]

状态保存：分片与远端 checkpoint

该目录还包含两个模型状态保存示例：save_sharded_state.py将每个 worker 的模型 state dict 直接保存为 checkpoint，使大模型在张量并行（tensor parallel）场景下加载时每个 worker 只需读取自己的分片而非整个 checkpoint，从而显著加速加载路径；save_remote_state.py则将状态保存到远端存储（--remote-model-save-url [protocol]://[host]:[port]/[model_name]）。典型用法形如：

python save_sharded_state.py --model-path /path/to/load --quantization deepspeedfp --tensor-parallel-size 8 python save_remote_state.py --model-path /path/to/load --tensor-parallel-size 8 --remote-model-save-url [protocol]://[host]:[port]/[model_name]

目录级说明文档

examples/runtime/engine/readme.md 将上述能力归纳为五类使用场景：Offline Batch Inference、Embedding Generation、Custom Server（Sanic 示例）、Token-In-Token-Out for RLHF、Inference Using FastAPI，并指出引擎对超大批次会自动调度以避免 OOM。

Hidden States：提取隐藏状态的两条路径

hidden_states目录（见 examples/runtime/hidden_states）提供隐藏状态提取示例。README 特别提醒：该功能可能因 CUDA Graph 重建而降低吞吐，因为服务端需要按配置的最大隐藏状态模式构建 CUDA Graph；请求可以选择该模式或更弱的模式而不会触发按模式重捕图（mode-dependent recapture）。

两条路径对应两个脚本：

• Engine 路径（hidden_states_engine.py）：构造引擎时传入return_hidden_states_mode="last"，生成时在采样参数之外单独传return_hidden_states="last"，结果从output["meta_info"]["hidden_states"]取出并转为torch.bfloat16张量：

llm = sgl.Engine( model_path="Alibaba-NLP/gte-Qwen2-1.5B-instruct", return_hidden_states_mode="last", ) outputs = llm.generate( prompts, sampling_params=sampling_params, return_hidden_states="last", ) for prompt, output in zip(prompts, outputs): hidden_state = torch.tensor(output["meta_info"]["hidden_states"], dtype=torch.bfloat16) print(f"Prompt: {prompt}\nGenerated text: {output['text']}\nLast hidden state: {hidden_state}")

• Server 路径（hidden_states_server.py）：以--return-hidden-states-mode last启动服务端，然后向/generate提交请求，并在请求体中携带"return_hidden_states": "last"，同样从响应meta_info.hidden_states中取回向量。脚本内部通过sglang.utils.launch_server_cmd自动拉起并回收服务进程，可独立运行：

python hidden_states_server.py

两条路径的关键参数保持一致：服务端启动参数--return-hidden-states-mode决定 CUDA Graph 配置的最大模式，请求级参数return_hidden_states决定本次请求实际提取的模式（当前支持last，即最后一层隐藏状态）。

Multimodal：多模态输入的多模型示例

multimodal目录（见 examples/runtime/multimodal）展示如何用 URL、本地文件或编码后的数据向多模态模型发起请求。README 概述了四类模型：

以 Llava-OneVision 为例，服务端启动命令为：

python3 -m sglang.launch_server --model-path lmms-lab/llava-onevision-qwen2-72b-ov --port=30000 --tp-size=8 python3 llava_onevision_server.py

llava_onevision_server.py 内部较为完整，包含四类测试：

1. 图像流式请求：OpenAI SDK 中以image_url类型携带 URL，stream=True逐块输出；
2. 多图流式请求：多个image_url条目，每个条目用"modalities": "multi-images"标注，配合一段文本提示模型描述两张图；
3. 视频请求：先用sglang.srt.utils.video_decoder.VideoDecoderWrapper解码视频，用np.linspace均匀采样最多 32 帧，逐帧转 JPEG 并 base64 编码，以data:image/jpeg;base64,...形式 +"modalities": "video"组装进消息（依赖pip install torchcodec与pip install protobuf==3.20.0）；
4. 速度测试：分别对图像与视频请求计时，输出 Total / Completion / Prompt tokens 与每秒 token 数（total_tokens / elapsed等）。

Token In, Token Out：以 token 为边界的推理工作流

token_in_token_out目录（见 examples/runtime/token_in_token_out）展示了 RLHF 等场景中常用的"输入 token、输出 token"工作流——调用方自行完成分词，SGLang 只负责推理并返回生成的 token id，全程绕开文本层。目录包含四个脚本，覆盖 LLM/VLM × Engine/Server 四个组合：

• token_in_token_out_llm_engine.py
• token_in_token_out_llm_server.py
• token_in_token_out_vlm_engine.py
• token_in_token_out_vlm_server.py

Server 版（token_in_token_out_llm_server.py）的关键在于服务端以--skip-tokenizer-init启动（跳过分词器初始化），随后向/generate提交input_ids：

python token_in_token_out_llm_server.py # 脚本内部自动启动服务端

json_data = { "input_ids": token_ids_list, # 直接给 token id，而非文本 "sampling_params": sampling_params, } response = requests.post(f"http://localhost:{port}/generate", json=json_data)

Engine 版（token_in_token_out_llm_engine.py）同样以sgl.Engine(model_path=MODEL_PATH, skip_tokenizer_init=True)构造引擎，用llm.generate(input_ids=token_ids_list, ...)推理。两个版本的输入都通过sglang.srt.utils.hf_transformers_utils.get_tokenizer(MODEL_PATH)获取 HuggingFace 分词器完成tokenizer.encode，输出则读取output["output_ids"]并用tokenizer.decode还原文本。

VLM 版（如token_in_token_out_vlm_server.py）则引入图像 token 的处理：通过sglang.lang.chat_template.get_chat_template_by_model_path(MODEL_PATH)取对话模板中的image_token拼进文本，配合图片数据一并编码为input_ids，从而将多模态输入也纳入 token 级工作流。

结合源码的进一步探索

如果想深入验证本文涉及的接口行为，可以直接阅读仓库源码与测试：

• 引擎实现与参数解析位于 python/sglang/srt/server_args.py（ServerArgs与add_cli_args），sgl.Engine的上层封装在 python/sglang/lang/llm.py 附近；
• continue_final_message、lora_path等 OpenAI 兼容请求参数的处理可在python/sglang/srt的入口与 HTTP 路由层搜索对应字段确认；
• 各类示例在 test/manual、test/registered 中均有对应回归测试，可作为理解参数取值与边界的补充材料。

整体来看，examples/runtime目录是 SGLang 运行时能力最直观的"活文档"：面向外部服务的 Native API 示例解决"如何部署与调用"，离线 Engine 示例解决"如何在进程内构建批处理与自定义服务"，Hidden States、Multimodal 与 Token-In-Token-Out 则覆盖嵌入提取、多模态理解与 RLHF 对齐等进阶工作流。读者可以按需挑选对应脚本，以"先起服务端、再跑客户端"或"直接运行 engine 脚本"两种模式快速落地。

【免费下载链接】sglangSGLang is a high-performance serving framework for large language models and multimodal models.项目地址: https://gitcode.com/GitHub_Trending/sg/sglang