Instructions to use poolside/Laguna-S-2.1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use poolside/Laguna-S-2.1 with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="poolside/Laguna-S-2.1", trust_remote_code=True) messages = [ {"role": "user", "content": "Who are you?"}, ] pipe(messages)# Load model directly from transformers import AutoTokenizer, AutoModelForCausalLM tokenizer = AutoTokenizer.from_pretrained("poolside/Laguna-S-2.1", trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained("poolside/Laguna-S-2.1", trust_remote_code=True, device_map="auto") messages = [ {"role": "user", "content": "Who are you?"}, ] inputs = tokenizer.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) outputs = model.generate(**inputs, max_new_tokens=40) print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:])) - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- vLLM
How to use poolside/Laguna-S-2.1 with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "poolside/Laguna-S-2.1" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "poolside/Laguna-S-2.1", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker
docker model run hf.co/poolside/Laguna-S-2.1
- SGLang
How to use poolside/Laguna-S-2.1 with SGLang:
Install from pip and serve model
# Install SGLang from pip: pip install sglang # Start the SGLang server: python3 -m sglang.launch_server \ --model-path "poolside/Laguna-S-2.1" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "poolside/Laguna-S-2.1", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker images
docker run --gpus all \ --shm-size 32g \ -p 30000:30000 \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --env "HF_TOKEN=<secret>" \ --ipc=host \ lmsysorg/sglang:latest \ python3 -m sglang.launch_server \ --model-path "poolside/Laguna-S-2.1" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "poolside/Laguna-S-2.1", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }' - Docker Model Runner
How to use poolside/Laguna-S-2.1 with Docker Model Runner:
docker model run hf.co/poolside/Laguna-S-2.1
Reasoning stream disappears when a tools array is present (reasoning_tokens = 0)
Model: poolside/Laguna-S-2.1
Observed via: OpenRouter POST /api/v1/chat/completions, streaming (SSE)
Date: 2026-07
Summary
Laguna emits a normal reasoning stream (delta.reasoning / reasoning_details of type reasoning.text, with usage.completion_tokens_details.reasoning_tokens > 0) on plain requests. The moment the request includes a callable tools array (default tool_choice), the separate reasoning stream disappears entirely — reasoning_tokens drops to 0 and the model's step-by-step thinking is written into the answer content instead.
Per the model card, Laguna is intended to "reason before calling tools and between tool calls," so this appears to be a serving/parser-layer regression, not intended behavior.
Minimal Reproduction
A — reasoning works (no tools)
{
"model": "poolside/laguna-s-2.1",
"stream": true,
"messages": [{ "role": "user", "content": "What is 17 * 23?" }]
}
Result: streams delta.reasoning (~2,200–3,300 chars across runs), reasoning_tokens ≈ 600, then the answer.
B — reasoning gone (one no-op tool, callable)
{
"model": "poolside/laguna-s-2.1",
"stream": true,
"messages": [{ "role": "user", "content": "What is 17 * 23?" }],
"tools": [{
"type": "function",
"function": {
"name": "noop",
"description": "Does nothing.",
"parameters": { "type": "object", "properties": {} }
}
}]
}
Result: 0 reasoning-stream chars, reasoning_tokens = 0; the reasoning appears inline in content.
C — reasoning returns with the same tools array, made non-callable
{ "...identical to B...", "tool_choice": "none" }
Result: reasoning stream returns (~2,500 chars). This isolates the trigger to tool-callability, not tool schema size or prompt.
Evidence Table
| Request | Reasoning stream | reasoning_tokens |
|---|---|---|
| No tools | Yes (~2.5k chars) | ~600 |
One no-op tool (tool_choice: auto) |
None | 0 |
One no-op tool + tool_choice: "none" |
Yes | >0 |
What does NOT restore reasoning
All of the following still produce 0 reasoning / reasoning_tokens = 0 while a callable tool is present:
reasoning: { effort: "low" | "medium" | "high" | "max" }reasoning: { enabled: true }chat_template_kwargs: { enable_thinking: true }(top-level andextra_body-nested)- System-prompt instructions to "show your full chain of thought"
Diagnosis
The suppression is gated purely by the presence of a callable tool (a single no-op function is enough), independent of token load, tool schema, effort level, or system prompt. reasoning_tokens = 0 indicates the reasoning tokens are not generated when the tool-call path is active — the reasoning is not produced-then-hidden, it is absent.
This is consistent with the reasoning parser and tool-call parser being separate serving-layer paths where enabling tool-call emission blocks the reasoning stream. The tool_choice: "none" result confirms the model itself will still reason with tools in context; the loss occurs specifically when tool invocation is enabled.
Expected vs. Actual
- Expected (per model card): reasoning stream present before/between tool calls, with tools callable.
- Actual: reasoning stream present only when tools are absent or
tool_choice: "none".
Small correction to my diagnosis: reasoning_tokens = 0 does not necessarily mean reasoning-like text was not generated, because such text appears inline in content. More precisely, the callable-tool path appears to stop delimiting/parsing/accounting for that text as a separate reasoning channel.