Deployment
Install SGLang
Install SGLang
Use an SGLang build that includes Qwen3.8-Flash-Next support (v0.5.22 or later).The deployment panel can render a complete
Command
docker run command for the selected hardware and options. See Install SGLang with Docker for host setup.DGX Spark notes (1x GB10 with the N-gram table on NVMe, or 2x GB10 TP=2)
DGX Spark notes (1x GB10 with the N-gram table on NVMe, or 2x GB10 TP=2)
The NVFP4 checkpoint is 126 GiB (78 GiB of experts and dense weights plus a 47.7 GiB FP8 N-gram table), so it does not fit one DGX Spark’s 128 GB of unified memory, and
--ple-offload-embedding does not help there: on GB10 the “offloaded” pinned-host table comes out of the same pool as the GPU weights. The two-node shape is TP=2 across two Sparks over the ConnectX-7 200GbE link, with --no-ple-offload-embedding keeping the table GPU-resident and sharded (~65 GB of weights per node). A single Spark works only with the table file-backed on NVMe (see the Single Spark bullet below).- Launch order. Start rank 1 first, then rank 0 within a few seconds. When re-launching, stop both ranks and confirm nothing listens on the rendezvous port before starting again: a new rank 1 attaching to a stale rank 0 store fails with a gloo “Connection reset by peer”.
- NCCL. The cross-node decode CUDA-graph deadlock seen on an earlier DGX Spark stack was on NCCL 2.28.x; both builds these images load have been verified here for TP=2 across two Sparks:
dev-qwen38-next-localruns its pip NCCL 2.29.7 (a system 2.28.3 is also present but not loaded),qwen38flashnextits 2.30.7. Confirm with the startup log linesglang is using nccl==…, which reports the library actually loaded. If your Sparks also have a slower management NIC, pinNCCL_SOCKET_IFNAME/GLOO_SOCKET_IFNAMEto the 200GbE interface; with--dist-init-addron the 200GbE address the verified runs picked it without pinning. - Memory. Both cells run
--mem-fraction-static 0.85, which leaves ~8–12 GiB of host memory free per node under load (measured through GSM8K at full concurrency and a 100k-token prefill). Two precautions for long-context work beyond that:PYTORCH_CUDA_ALLOC_CONF=expandable_segments:Truestops variable-shape chunked-prefill buffers from fragmenting the caching allocator at 200k+ contexts, and a host-side watchdog that kills the server whenMemAvailabledrops below a few GiB, because a unified-memory exhaustion can take the whole box down and needs a power cycle to recover. - Concurrency. The hybrid GDN/QSA model reserves mamba state slots per running request (5 with the default
extra_bufferradix strategy, 4 withextra_buffer_lazy), and the scheduler caps--max-running-requeststo what the mamba pool admits; read the effective value from the startup log, not from/get_server_info. The cells pin--max-mamba-cache-sizeto requests × slots (24 × 5 = 120 for low latency, 96 × 4 = 384 for high throughput); raising concurrency further takes memory from the KV pool one-for-one. - Flags. The cells are the model card’s TP=2 recipe without
--mamba-track-interval 64: the default of 256 tokens satisfies the constraints (a multiple of the 64-token page, at least the 4 draft tokens) and leaves a ~40% larger KV pool (1.48M tokens at 24 concurrent with MTP, 1.07M at 96 without), at the cost of coarser prefix-cache reuse of the recurrent state.--trust-remote-codeis not needed; the architecture is native to SGLang. - Measured. 100k-token prefill at 2,400–2,840 tok/s; MTP accept length 3.5–3.7 of 4 draft tokens on non-thinking output (lower, ~2.5, on thinking output).
- Single Spark (file-backed PLE table). One GB10 holds the checkpoint only if the 47.7 GiB FP8 N-gram table leaves memory entirely: with PLE Offload = On (NVMe file) (
--ple-offload-embedding --ple-offload-backend file, from #37068, merged intoqwen4-main-squashed) SGLang creates a sparse 47.7 GiB file under$SGLANG_CACHE_DIR/ple/<model>(relocate with--ple-offload-dir; put it on the local NVMe and mount that directory into the container), fills it on boot, and the gather kernel reads rows through the host page tables; the table’s resident set stays at 0 while serving, with hot pages in page cache (capped at 8 GiB bySGLANG_QWEN4_PLE_FILE_RSS_BUDGET_GB). The 78.3 GiB of experts and dense weights stay resident (the server logs ~80 GB after load, which also counts the CUDA context and allocator overhead) and--mem-fraction-static 0.85leaves ~12–18 GB for the pools, so concurrency is pinned low: 8 requests with MTP (40 fp32 mamba slots of ~113 MB each) or 24 without (96 slots onextra_buffer_lazy). Measured on4ccff141db: MTP cell 27.5 tok/s single-stream (TPOT 33.6 ms) and 71.7 tok/s output at 8; no-MTP cell 15.9 tok/s single-stream and 83 tok/s output at 24; host memory never below 10 GiB. Boot-time caveat: every boot rewrites the whole table through the mapping; on an already-populated file that is a read-modify-write per 4 KiB page with readahead disabled (MADV_RANDOM), ~17 MB/s and ~55 minutes; on a fresh sparse file it fills at GB/s and the boot takes ~10 minutes. Until that is fixed upstream, delete the previousple_table_*.binbefore each boot. - NVIDIA export (NVFP4 (NVDA)).
nvidia/Qwen3.8-Flash-Next-NVFP4is a ModelOpt MIXED_PRECISION checkpoint (NVFP4 experts, FP8 N-gram table, FP8 block-scaled MTP experts) and needs the loader from #38121, merged intoqwen4-main-squashed(the branch the Python install path builds and thelmsysorg/sglang:dev-qwen38-next-localimage ships); theqwen38flashnextimage predates it and cannot load this export. Do not pass--quantizationfor it (it resolves tomodelopt_mixed), and pass--moe-runner-backend flashinfer_cutlassexplicitly: the mixed-precision auto-default picksflashinfer_trtllmon GB10, which the NVFP4 MoE method rejects at autotune. Its MTP experts are FP8 block-scaled with 128-wide blocks, which two ranks split mid-block (640 / 2 = 320); SGLang refines their block scales to a finer grid so each rank loads its 320 rows, but the two-node low-latency cell was measured with the MTP draft from the RadixArk export, the same trained head kept in BF16 there. On a single Spark (TP=1, file-backed table) nothing is sharded, so the export’s own MTP head loads directly. The single-Spark NVDA cells use the same pins as the RDXA ones (8 requests with MTP, 24 without); the smaller fp8 draft leaves a 174k-token KV pool with MTP, against 93k for the RadixArk cell. Measured on theqwen4-main-squashedtip4ccff141db(#38121 merged) at TP=2: 47.4 tok/s single-stream with MTP, 253 tok/s output at 96 concurrent without, the same as the RadixArk export.
RTX PRO 6000 notes (1x 96 GB, TP=1)
RTX PRO 6000 notes (1x 96 GB, TP=1)
The NVFP4 checkpoint fits a single 96 GB RTX PRO 6000 Blackwell (SM120) only with the 47.7 GiB FP8 N-gram table in CPU pinned memory (
--ple-offload-embedding, the forced setting of the PLE Offload row on this hardware): the other 78 GiB of the checkpoint loads onto the card. After the loader’s temporaries are collected, 74.7 GiB stays resident without speculative decoding and 81.8 GiB with it (the draft head is 0.5 GiB; the rest is memory the loader still holds), leaving 19.4 GiB and 12.3 GiB of the 94.2 GiB the process can use. --mem-fraction-static keeps (1 − fraction) × 94.2 GiB of that as runtime slack and the pools take the rest: 6.6 GiB of slack and 12.8 GiB of pools at 0.93, 3.8 GiB and 8.3 GiB at 0.96. (The 81 GiB “mem usage” in the load log is the delta before that collection.) The host needs ≥ 64 GB of free RAM for the locked table (plus page cache for the checkpoint) and Docker needs --ulimit memlock=-1, or the pinned allocation fails.-
Concurrency. The hybrid model reserves mamba state slots per running request, and the scheduler caps
--max-running-requeststo what the state pool admits: with the defaultextra_bufferstrategy (5 fp32 slots per request at 0.109 GiB) that is 3 requests with MTP and 12 without on this card. The cells keep prefix caching on and get to 16 / 64 with three levers:--mamba-radix-cache-strategy extra_buffer_lazy(4 slots per request),SGLANG_OPT_MAMBA_SKIP_DECODE_LOCK=1(3; a running request’s prefix state is no longer pinned in the radix tree during decode, so it can be evicted, which trades cache retention, not numerics), and--mamba-ssm-dtype bfloat16(0.055 GiB per slot).--max-mamba-cache-sizeis pinned to requests × 3 (48 / 192). The ceilings from the pool arithmetic are ~20 requests with MTP (each request carries 4 intermediate draft states) and ~70 without; turning prefix caching off (--disable-radix-cache, 1 slot per request) reaches 24 / 96 on this card and was verified too, but re-prefills every prompt. -
Linear-attention kernels. Left on auto. On SM120 the server resolves decode, prefill and verify to triton — the same GDN kernels the fp32 runs and the DGX Spark cells use; the bf16-state FlashInfer GDN auto-default applies only to SM100. An explicit
--linear-attn-decode-backend flashinferalso runs on this card and measured the same TPOT (within 0.3 ms) and accuracy, so there is nothing to gain from pinning either. -
Memory headroom. With the state pool pinned, the KV pool absorbs the rest of the static budget, so
--mem-fraction-staticis what sets the activation headroom. 4096-token prefill chunks of ShareGPT-length prompts peak 1.5–2.6 GB above the post-graph-capture level, and cells left with 2.4 GB free OOMed in the GDN short-conv during prefill. The cells keep ≥ 4 GB free after graph capture and ≥ 2.3 GB at the measured peak: 0.96 with MTP (78k-token KV pool, ~4.9k per request at 16) and 0.93 without (98k tokens, ~1.5k per request at 64; 0.94 gives 138k tokens with 2.3 GB at peak).PYTORCH_CUDA_ALLOC_CONF=expandable_segments:Trueis set on both. -
Accuracy. Full GSM8K, 1,319 questions, on the
lmsysorg/sglang:dev-qwen38-next-localimage, in two protocols. Chat completions API with thinking off, greedy, an 8,192-token budget, answer parsed from a final “The answer is N” line (the protocol of the DGX Spark rows, and the figure on the benchmark card): 96.9% for the MTP cell and 96.9% for the no-MTP cell (RadixArk export); 97.3% and 97.0% for the NVIDIA export.python -m sglang.test.run_eval --eval-name gsm8k --num-examples 1319 --max-tokens 16384(5-shot, greedy, last-number scorer, chat template with thinking on): 97.72% / 97.79% (RadixArk), 97.41% / 97.72% (NVIDIA). Measured on the4ccff141dbbuild, which carries the #36811 and #38290 router fixes. -
Measured (1024-in / 256-out random prompts,
ignore_eos). MTP vs no-MTP at 1 request: TTFT 115 vs 116 ms median, TPOT 5.9 vs 11.4 ms, 148 vs 83 tok/s. At 16: TPOT 19.3 vs 25.6 ms, 613 vs 524 tok/s. No-MTP at 64: TPOT 55 ms, 861 tok/s, 3.4 req/s. ShareGPT chat (thinking off, ≤ 512 output tokens): 785 tok/s at 16-way with MTP, 1,258 tok/s at 64-way without. MTP accept length 3.3 of 4 on GSM8K / random prompts, 2.9 on long-form ShareGPT answers. On thedev-qwen38-next-localimage (4ccff141db): 6.0 / 11.44 ms TPOT at 1 request (MTP / no MTP), 685 / 561 tok/s at 16, 909 tok/s at 64 without MTP, accept length 3.16. -
NVIDIA export (NVFP4 (NVDA)).
nvidia/Qwen3.8-Flash-Next-NVFP4runs on this card with the same shape, pools and flags as the RadixArk cells on thelmsysorg/sglang:dev-qwen38-next-localimage (it carries the loader from #38121;qwen38flashnextcannot load this export). Do not pass--quantization: the checkpoint resolves tomodelopt_mixed. Low latency keeps the in-checkpoint MTP head: at TP=1 its fp8 block-scaled experts need no sharding, and #38121 runs them on triton under theflashinfer_cutlasspin. The RadixArk BF16 draft measured the same here (accept 3.33 vs 3.31, TPOT 18.5 vs 19.1 ms at 16), so the cell stays single-checkpoint. Verified on that image (4ccff141db): full GSM8K in the Accuracy bullet above; 6.02 ms TPOT at 1 request with MTP, 675 output tok/s at 16; 906 output tok/s at 64 without, the same as the RadixArk export. The smaller fp8 draft leaves a ~170k-token KV pool at 16 concurrent. To shrink the draft further, add--speculative-draft-model-quantization modelopt_fp4(needs a build that includes #48295; thedev-qwen38-next-localimage ignores this flag): it converts the 512 block-FP8 MTP experts to NVFP4 while they load (the online path--quantization modelopt_fp4uses for FP8 checkpoints), and the draft then runs on the sameflashinfer_cutlassNVFP4 MoE path as the target. In a TP=1 test on upstream main with 8 running requests (--mem-fraction-static 0.94 --max-mamba-cache-size 40 --disable-radix-cache), free memory after the draft load rose from 14.7 to 15.7 GB and the KV pool from 24,320 to 64,064 tokens, with GSM8K (200 questions, thinking off) at 97.0% vs 96.5% and MTP accept length 3.50 in both. The conversion is verified on RTX PRO 6000 and GB200; it is untested on GPUs without native NVFP4 MoE kernels, such as H100.
Playground
The Playground is where you experiment with SGLang features beyond the verified matrix. The Deploy panel above only emits combinations the SGLang team has signed off on; the Playground lets you turn on additional knobs on top of whichever cell the Deploy panel is currently showing.Agentic Long-Context Deployment
Agentic workloads, such as coding agents and other multi-turn, tool-using assistants, send long prompts whose prefixes grow and repeat from turn to turn. Serving them well depends on reusing the KV cache across turns, offloading it beyond GPU memory, and keeping each session on the workers that already hold its prefix. This section gives complete launch commands for such deployments, each benchmarked in SemiAnalysis InferenceX and linked to the run that measured it. Pick a hardware platform, checkpoint, deployment shape, concurrency, KV cache offloading mechanism and router to get every process of the deployment as a raw command, one tab per process in launch order.- Router. Each configuration was submitted behind one front door: Dynamo (
dynamo.frontendwithdynamo.sglangworkers) or SGLang (sglang.launch_server, behind a router when there are several workers or DP-attention ranks). - KV offload. Choose among these KV cache offloading mechanisms: none (GPU KV only), HiCache (host DRAM), or a Mooncake store attached through the external linker. The Mooncake option needs an image whose SGLang build includes
--enable-unified-cache-external-linker. - Container image. Run the commands inside the image listed for each configuration. Several are SGLang nightly images, so flag names follow that image.
MI355X deployment measured with SemiAnalysis InferenceX
AMD’s Quark MXFP4 checkpoint with NEXTN MTP on one MI355X (TP1), with GPU-resident KV up to concurrency 16 and HiCache offload above it, benchmarked in SemiAnalysis InferenceX (InferenceX #4680, #4542, #4779) at concurrency 1–80. Concurrency 12 and 16 run the default path; concurrency 1–8 run the FlyDSL monokernel; concurrency 24, 48 and 80 add an FP8 KV cache and HiCache host-memory offload.- Container image.
lmsysorg/sglang-rocm:v0.5.23-rocm10-mi35x-20261031(sha256:3867dc07ba2530f914e1f210ed829f7a572a75286c8c362dbc22cbecf9b5a7e6, the image tested in InferenceX, run without patches). This dated nightly is built from SGLangmainate9c18259c7with AITER285579b6and the monokernel packagesgl-amd-monoatb10f3b71, the pin SGLang carries since #47483. - Checkpoint.
amd/Qwen3.8-Flash-Next-Quark-MXFP4-AttnFP8-PLEFP8has MXFP4 MoE experts (the MTP head’s included), FP8 attention and an FP8 N-gram table, 116 GiB in all. - PLE offload. At concurrency 12 to 80,
--ple-offload-embeddingkeeps the 47.7 GiB FP8 N-gram table in pinned host memory, which leaves about 82 GB of weights on the GPU. On ROCm the server leaves it off unless you pass the flag. Offloading this checkpoint also needs the--json-model-override-argsvalue, which declares the table’s FP8 storage up front; without it the server stops at load withfp8 PLE auto-switch is unsupported with ple_offload_embedding. The monokernel reads the table on the GPU, so the concurrency 1–8 command leaves the offload off; it keeps the override value, as in InferenceX. - Memory fraction. For models with a context above 8,192 tokens, the aiter attention backend multiplies
--mem-fraction-staticby 0.85.SGLANG_AITER_HONOR_EXPLICIT_MEM_FRACTION=1keeps the value as given: 0.9 up to concurrency 16 and 0.88 at concurrency 24–80. - Monokernel (concurrency 1–8).
--enable-amd-monokernelruns MTP target verify (13 persistent launches per step) and every MTP draft step (one launch) through the FlyDSL kernels ofsgl-amd-mono, for up to 8 running requests on one MI355X (TP1). Other steps use the standard forward. It needs NEXTN with 3 steps, eagle-topk 1 and 4 draft tokens, and the Quark checkpoint above. Its verify writes the per-draft SSM states itself, so leave out--enable-linear-replayssm-spec. The flag is marked experimental, and SGLang stops at startup with the list of reasons if the setup is outside what the kernel supports. - Batch limits. At concurrency 12, 16 and 24, set
--max-running-requestsand--cuda-graph-max-bs-decodeto twice the concurrency, so request bursts above it still decode in a captured graph: 24, 32 and 48. At concurrency 48 and 80 set both to 128. With the monokernel, set both to the concurrency: 1, 2, 4 and 8. The commands below use concurrency 16, 8, 24, 48 and 80. - FP8 KV and HiCache (concurrency 24–80).
--kv-cache-dtype fp8_e4m3and--speculative-draft-kv-cache-dtype fp8_e4m3store the target and draft KV caches in FP8 E4M3, andSGLANG_USE_AITER_UNIFIED_ATTN=1switches the aiter backend to its unified-attention kernel. The Mamba state pool uses--mamba-radix-cache-strategy extra_buffer_lazywith--mamba-track-interval 256, and--max-mamba-cache-sizeis 960, 720 and 640 at concurrency 24, 48 and 80. HiCache (--enable-hierarchical-cachewith--hicache-io-backend kernel,--hicache-mem-layout page_firstand--hicache-write-policy write_back) offloads KV to host memory;--hicache-sizeis in gigabytes and is 200 at concurrency 24 and 298 at concurrency 48 and 80, inside the 299 GB host-memory share InferenceX gives each point. At concurrency 80,--strip-thinking-cachecaches only the prompt when a request finishes, and--mamba-max-states-per-path 2keeps at most two Mamba states per conversation path. These points keep ReplaySSM and the PLE offload of concurrency 12 and 16. - Thinking. The commands for concurrency 1–16 pass
--default-chat-template-kwargs '{"enable_thinking": false}', which makes non-thinking the default: the chat template opens each reply with an empty<think></think>block. The commands for concurrency 24–80 follow the InferenceX recipe, which leaves the flag out, so the model’s thinking-on default applies; add the flag for non-thinking replies. A request switches either default with"chat_template_kwargs": {"enable_thinking": true}orfalse.
Concurrency 12–16
Concurrency 1–8 (monokernel)
Concurrency 24
Concurrency 48
Concurrency 80
1. Model Introduction
Qwen3.8-Flash-Next is a multimodal Mixture-of-Experts model released as an early preview of the architecture Qwen4 is being built on — the same role Qwen3-Next played for Qwen3.5, whose hybrid Gated DeltaNet + Gated Attention design then carried through the Qwen3.5, Qwen3.6, Qwen3.7 and Qwen3.8 series. Qwen is publishing the architectural changes ahead of the full Qwen4 family so the community can evaluate them independently. It has 176B total parameters — 51B of which is an N-gram embedding table — and 6B active per token. Against Qwen3.7-Plus it cuts both training and inference cost substantially (training takes roughly 1/9 as much) while holding comparable overall quality. It takes text and images in, and the hosted production variant is served asqwen3.8-flash on QwenCloud.
The upgrades span four axes:
- Attention — GDN + QSA hybrid. Three of every four layers use Gated DeltaNet, which compresses history into a fixed-size recurrent state; the fourth is global attention running Qwen Sparse Attention (QSA). A lightweight indexer aggregates the sequence into micro-blocks, scores importance at block level, and selects the relevant regions — so the indexing overhead shrinks along with the attention itself. Unlike approaches that reuse indices across layers, QSA compresses independently per layer, which suits an architecture that interleaves GDN and attention. Qwen measures up to 10.2× prefill and 6.6× decode speedups for the QSA attention kernel at 1M tokens.
- Residual — Gated Residual (GR). The single residual stream widens into four parallel branches, with an element-wise dynamic gate controlling how much each layer reads from and writes back to each branch. Qwen reports one branch naturally becoming a long-range bus. The gate also suppresses activation outliers, and the residual state can be held in FP8.
- Embedding — N-gram Embedding. Lookups keyed on the local context (current token plus a few preceding ones) rather than a single token, adding 51B parameters at almost no extra per-token compute. Because lookup addresses are known in advance, the table can live in host memory and be prefetched asynchronously alongside model compute. The final model uses a single such layer near the start of the network.
- Optimization — Muon. Muon for the genuine 2-D linear maps (attention, GDN and MoE expert weights), AdamW for embeddings, the MoE router and GR’s low-rank parameters, with fused QKV / SwiGLU / GDN projections split before orthogonalization. The scaling law was refit for the new architecture, and batch-size warmup was dropped — it cost 18.8% more optimizer steps without improving the result.
temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0; for instruct (non-thinking) mode use temperature=0.7, top_p=0.80, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0. The checkpoint’s generation_config.json already ships the thinking preset (temperature=1.0, top_k=20, top_p=0.95), so leaving temperature / top_p unset is right for thinking mode — but it does not match the instruct preset, so set those values explicitly when you run with enable_thinking: false.
Each precision is its own repository:
| Precision | Repository | Where it runs |
|---|---|---|
| BF16 | Qwen/Qwen3.8-Flash-Next | H200, B200, B300, GB300, MI350X, MI355X |
| FP8 | Qwen/Qwen3.8-Flash-Next-FP8 | H200, B200, B300, GB300, MI350X, MI355X |
| NVFP4 (RDXA) | RadixArk/Qwen3.8-Flash-Next-NVFP4 | B200, B300, GB300, RTX PRO 6000, 1x or 2x DGX Spark (Blackwell only) |
| NVFP4 (NVDA) | nvidia/Qwen3.8-Flash-Next-NVFP4 (ModelOpt MIXED_PRECISION) | RTX PRO 6000, 1x or 2x DGX Spark (needs #38121: the dev-qwen38-next-local image or the Python install path) |
2. Advanced Usage
The
model argument in the examples below is the BF16 repo id. Every precision is a separate repo, so model has to be the checkpoint the server was actually launched with — …-Flash-Next-FP8 or …-Flash-Next-NVFP4. The Deploy panel’s cURL snippet always shows the right id for the cell you have selected.2.1 Reasoning
Qwen3.8-Flash-Next thinks by default, but thinking can be turned off: set"chat_template_kwargs": {"enable_thinking": false} per request, or --default-chat-template-kwargs '{"enable_thinking": false}' server-wide. The template then pre-fills an empty <think></think> block, so generation starts directly at the answer.
--reasoning-parser auto (toggle Reasoning Parser in the Parsers card of the Playground above) picks the matching parser from the chat template and splits the thinking into reasoning_content. Depth is requested with reasoning_effort: xhigh (the default), medium, or low — other values are rejected, and it has no effect while thinking is disabled. Thinking blocks are preserved by default (preserve_thinking: true); set "chat_template_kwargs": {"preserve_thinking": false} to keep only the latest turn’s.
Reasoning Example (Python)
Reasoning Example (Python)
Example
Example Output
Example Output
Output
2.2 Tool Calling
Add--tool-call-parser auto (toggle Tool Call Parser in the Parsers card of the Playground above) to surface structured tool calls via message.tool_calls. As with the reasoning parser, SGLang resolves the concrete detector from the chat template at startup. No Deploy cell sets it, so this is an opt-in: add the flag to the generated command, or flip the chip in the Playground.
With thinking on (the default), a generation that stops inside the reasoning block — for example at the max_tokens cap — leaves content empty and puts the partial reasoning in reasoning_content; with enable_thinking: false the answer lands in content directly. Print both so a bare None doesn’t mislead you.
Tool Calling Example (Python)
Tool Calling Example (Python)
Example
Example Output
Example Output
Output
