DeepSeek-V4 Flash Agentic 增强补丁

PATCH_DIR=/path/to/patch
VLLM_REPO=/vllm-workspace/vllm
VLLM_ASCEND_REPO=/vllm-workspace/vllm-ascend
MODEL_PATH=/models/DeepSeek-V4-Flash-w8a8-mtp

cd "$VLLM_REPO"
git apply --check "$PATCH_DIR/deepseek-v4-agentic-support.patch"
git apply "$PATCH_DIR/deepseek-v4-agentic-support.patch"

cd "$VLLM_REPO"
git apply -R --check "$PATCH_DIR/deepseek-v4-agentic-support.patch"
git apply -R "$PATCH_DIR/deepseek-v4-agentic-support.patch"
git diff --stat

cd /workspace

export HCCL_OP_EXPANSION_MODE=AIV
export USE_MULTI_BLOCK_POOL=1
export OMP_PROC_BIND=false
export OMP_NUM_THREADS=10
export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True
export ACL_OP_INIT_MODE=1
export TRITON_ALL_BLOCKS_PARALLEL=1

vllm serve "$MODEL_PATH" \
  --max_model_len 131072 \
  --max-num-batched-tokens 8192 \
  --served-model-name dsv4 \
  --gpu-memory-utilization 0.9 \
  --max-num-seqs 16 \
  --tensor-parallel-size 8 \
  --enable-expert-parallel \
  --quantization ascend \
  --async-scheduling \
  --additional-config '{"enable_cpu_binding": "true", "multistream_overlap_shared_expert": true}' \
  --speculative-config '{"num_speculative_tokens": 1, "method": "mtp"}' \
  --compilation-config '{"cudagraph_mode":"FULL_DECODE_ONLY"}' \
  --tokenizer-mode deepseek_v4 \
  --tool-call-parser deepseek_v4 \
  --enable-auto-tool-choice \
  --reasoning-parser deepseek_v4 \
  --port 8000

from openai import OpenAI
client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="EMPTY")
model = "dsv4"
messages = [
    {
        "role": "user",
        "content": "What is 17*19? Return only the final integer.",
    }
]

# Non-think
resp = client.chat.completions.create(
    model=model,
    messages=messages,
)
print("non_think:", resp.choices[0].message.content)

# Think High
resp = client.chat.completions.create(
    model=model,
    messages=messages,
    extra_body={
        "chat_template_kwargs": {
            "thinking": True,
            "reasoning_effort": "high",
        },
    },
)
print("think_high content:", resp.choices[0].message.content)
print("think_high reasoning:", getattr(resp.choices[0].message, "reasoning", None))

# Think Max
resp = client.chat.completions.create(
    model=model,
    messages=messages,
    extra_body={
        "chat_template_kwargs": {
            "thinking": True,
            "reasoning_effort": "max",
        },
    },
)
print("think_max content:", resp.choices[0].message.content)
print("think_max reasoning:", getattr(resp.choices[0].message, "reasoning", None))

from collections import defaultdict
from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="EMPTY")
tool_calls = defaultdict(lambda: {"name": "", "arguments": ""})
visible_content = []

stream = client.chat.completions.create(
    model="dsv4",
    messages=[
        {
            "role": "user",
            "content": "Call the weather tool for Beijing today.",
        }
    ],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Query weather by city.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {"type": "string"}
                    },
                    "required": ["location"],
                },
            },
        }
    ],
    temperature=0,
    max_tokens=256,
    stream=True,
)

for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if delta.content:
        visible_content.append(delta.content)
    for tc in delta.tool_calls or []:
        entry = tool_calls[tc.index]
        if tc.function:
            if tc.function.name:
                entry["name"] = tc.function.name
            if tc.function.arguments:
                entry["arguments"] += tc.function.arguments

print("visible_content:", repr("".join(visible_content)))
print("tool_calls:", dict(tool_calls))