[Skip to main content](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#__docusaurus_skipToContent_fallback)

On this page

Open WebUI provides first-class support for models that exhibit "thinking" or "reasoning" behaviors (such as DeepSeek R1, OpenAI o1, and others). These models often generate internal chains of thought before providing a final answer.

## How Thinking Tags Work [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#how-thinking-tags-work "Direct link to How Thinking Tags Work")

When a model generates reasoning content, it typically wraps that content in specific XML-like tags (e.g., `<think>...</think>` or `<thought>...</thought>`).

Open WebUI automatically:

1. **Detects** these tags in the model's output stream.
2. **Extracts** the content between the tags.
3. **Renders** the extracted content in a collapsible UI element labeled "Thought" or "Thinking".

This keeps the main chat interface clean while still giving you access to the model's internal processing.

## The `reasoning_tags` Parameter [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#the-reasoning_tags-parameter "Direct link to the-reasoning_tags-parameter")

You can customize which tags Open WebUI should look for using the `reasoning_tags` parameter. This can be set on a **per-chat** or **per-model** basis.

### Default Tags [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#default-tags "Direct link to Default Tags")

By default, Open WebUI looks for several common reasoning tag pairs:

- `<think>`, `</think>`
- `<thinking>`, `</thinking>`
- `<reason>`, `</reason>`
- `<reasoning>`, `</reasoning>`
- `<thought>`, `</thought>`
- `<|begin_of_thought|>`, `<|end_of_thought|>`

### Customization [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#customization "Direct link to Customization")

If your model uses different tags, you can provide a list of tag pairs in the `reasoning_tags` parameter. Each pair is a tuple or list of the opening and closing tag.

## Configuration & Behavior [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#configuration--behavior "Direct link to Configuration & Behavior")

- **Stripping from Payload**: The `reasoning_tags` parameter itself is an Open WebUI-specific control and is **stripped** from the payload before being sent to the LLM backend (OpenAI, Ollama, etc.). This ensures compatibility with providers that do not recognize this parameter.
- **Chat History**: Reasoning content is preserved in chat history and **sent back to the model** across turns. When building messages for subsequent requests, Open WebUI serializes the reasoning content with its original tags (e.g., `<think>...</think>`) and includes it in the assistant message's `content` field. This allows the model to "remember" its previous reasoning steps across the entire conversation.
- **UI Rendering**: Internally, reasoning blocks are processed and rendered using a specialized UI component. When saved or exported, they may be represented as HTML `<details type="reasoning">` tags.

* * *

## Open WebUI Settings [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#open-webui-settings "Direct link to Open WebUI Settings")

Open WebUI provides several built-in settings to configure reasoning model behavior. These can be found in:

- **Chat Controls** (sidebar) → **Advanced Parameters**: per-chat settings
- **Workspace** → **Models** → **Edit Model** → **Advanced Parameters**: per-model settings (Admin only)
- **Admin Panel** → **Settings** → **Models** → select a model → **Advanced Parameters**: alternative per-model settings location

### Reasoning Tags Setting [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#reasoning-tags-setting "Direct link to Reasoning Tags Setting")

This setting controls how Open WebUI parses and displays thinking/reasoning blocks:

| Option | Description |
| --- | --- |
| **Default** | Uses the system default behavior |
| **Enabled** | Explicitly enables reasoning tag detection using default `<think>...</think>` tags |
| **Disabled** | Turns off reasoning tag detection entirely |
| **Custom** | Allows you to specify custom start and end tags |

#### Using Custom Tags [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#using-custom-tags "Direct link to Using Custom Tags")

If your model uses non-standard reasoning tags (e.g., `<reasoning>...</reasoning>` or `[思考]...[/思考]`), select **Custom** and enter:

- **Start Tag**: The opening tag (e.g., `<reasoning>`)
- **End Tag**: The closing tag (e.g., `</reasoning>`)

This is useful for:

- Models with localized thinking tags
- Custom fine-tuned models with unique tag formats
- Models that use XML-style reasoning markers

### think (Ollama) [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#think-ollama "Direct link to think (Ollama)")

This Ollama-specific setting enables or disables the model's built-in reasoning feature:

| Option | Description |
| --- | --- |
| **Default** | Uses Ollama's default behavior |
| **On** | Explicitly enables thinking mode for the model |
| **Off** | Disables thinking mode |

note

This setting sends the `think` parameter directly to Ollama. It's separate from how Open WebUI parses the response. You may need both this setting AND proper reasoning tags configuration for the full experience.

### Reasoning Effort [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#reasoning-effort "Direct link to Reasoning Effort")

For models that support variable reasoning depth (like some API providers), this setting controls how much effort the model puts into reasoning:

- Common values: `low`, `medium`, `high`
- Some providers accept numeric values

info

Reasoning Effort is only applicable to models from specific providers that support this parameter. It has no effect on local Ollama models.

* * *

## Interleaved Thinking with Tool Calls [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#interleaved-thinking-with-tool-calls "Direct link to Interleaved Thinking with Tool Calls")

When a model uses **native function calling** (tool use) within a single turn, Open WebUI preserves the reasoning content and sends it back to the API for subsequent calls within that turn. This enables true "interleaved thinking" where:

1. Model generates reasoning → makes a tool call
2. Tool executes and returns results
3. Model receives: original messages + previous reasoning + tool call + tool result
4. Model continues reasoning → may make more tool calls or provide final answer
5. Process repeats until the turn completes

### How It Works [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#how-it-works "Direct link to How It Works")

During a multi-step tool calling turn, Open WebUI:

1. **Captures** reasoning content from the model's response (via `reasoning_content`, `reasoning`, or `thinking` fields in the delta)
2. **Stores** it in content blocks alongside tool calls
3. **Serializes** the reasoning with its original tags (e.g., `<think>...</think>`) when building messages for the next API call
4. **Includes** the serialized content in the assistant message's `content` field

This ensures the model has access to its previous thought process when deciding on subsequent actions within the same turn.

### How Reasoning Is Sent Back [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#how-reasoning-is-sent-back "Direct link to How Reasoning Is Sent Back")

There are two parallel paths, and which one applies depends on **how the prior turn's reasoning was captured**, not on the provider you're sending to.

#### Path 1: Reasoning embedded in `content` (default for most providers) [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#path-1-reasoning-embedded-in-content-default-for-most-providers "Direct link to path-1-reasoning-embedded-in-content-default-for-most-providers")

When a model streams reasoning as `<think>…</think>` (or any other configured tag pair) inline in its content, Open WebUI keeps those tags as part of `message.content`. On the next turn the message is forwarded to the LLM verbatim, tags and all. Nothing is dropped, no provider-specific handling kicks in. This is the path you're most likely already on. It is also what the [Interleaved Thinking with Tool Calls](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#interleaved-thinking-with-tool-calls) section above describes.

#### Path 2: Reasoning captured into a structured `output` array [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#path-2-reasoning-captured-into-a-structured-output-array "Direct link to path-2-reasoning-captured-into-a-structured-output-array")

If the upstream stream emits `reasoning_content` / `reasoning` / `thinking` deltas (rather than text tags), typical for **OpenAI o-series**, **DeepSeek's official API**, **llama.cpp** with reasoning enabled, or **Ollama** with the `--reasoning-parser` flag, Open WebUI captures those deltas into a separate `reasoning` item inside the assistant message's `output` array. The displayed `content` only contains a `<details type="reasoning">` block for the UI; the structured form lives on `output`.

When that message is replayed to the LLM (within a tool-call loop or on the next user turn), Open WebUI rebuilds it from `output` rather than forwarding the rendered `content`. The format used for the rebuilt reasoning depends on the **connection's `Provider` setting** ( **Admin Settings → Connections → OpenAI → Provider** dropdown, options are `Default`, `Azure OpenAI`, `llama.cpp`; Ollama connections are detected automatically):

| Connection `Provider` | Rebuilt reasoning format |
| --- | --- |
| Ollama (auto-detected) | Wrapped in tags inside `content`: `<think>…</think>` |
| `llama.cpp` | Top-level `reasoning_content` field on the assistant message |
| `Default` / `Azure OpenAI` | Reasoning is **omitted** from the rebuilt message |

The "omit on default/strict" choice is deliberate: OpenAI, Azure OpenAI, Vertex AI, and similar Chat Completions APIs reject assistant messages with unknown fields, and they don't expect their own reasoning echoed back on the next call (they manage continuity stateside via `previous_response_id` for the Responses API, or simply don't need it). Pipe functions and filters can re-inject reasoning in a provider-specific shape when needed.

For Ollama, a rebuilt message looks like:

```
{
  "role": "assistant",
  "content": "<think>Let me search for the current weather data...</think>",
  "tool_calls": [...]
}
```

For a `llama.cpp` connection it looks like:

```
{
  "role": "assistant",
  "content": "",
  "reasoning_content": "Let me search for the current weather data...",
  "tool_calls": [...]
}
```

### Provider Compatibility [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#provider-compatibility "Direct link to Provider Compatibility")

| Provider type | Path 1 (tags in `content`) | Path 2 (structured `output`) |
| --- | --- | --- |
| OpenAI-compatible APIs that emit `<think>` tags inline (DeepSeek-R1 via Ollama, Qwen3 with the reasoning parser, etc.) | ✅ Round-trips automatically. | n/a |
| Ollama (connection auto-tagged as `ollama`) | ✅ Round-trips. | ✅ Rebuilt as `<think>…</think>` in `content`. |
| llama.cpp (connection _Provider_ set to `llama.cpp`) | ✅ Round-trips if the model uses tags. | ✅ Rebuilt as `reasoning_content` field. |
| OpenAI o-series (Responses API) | n/a (o-series doesn't expose reasoning text). | ⚠️ Reasoning continuity is handled by `previous_response_id`, not by re-sending content. |
| OpenAI / Azure / Vertex AI (Chat Completions, _Provider_`Default`) | ✅ Tags pass through as text (most strict providers tolerate them). | ⚠️ Structured reasoning is omitted on rebuild (use a pipe/filter to re-inject if you need it). |
| Anthropic (extended thinking) | ⚠️ Tags work, but the native API expects `{"type": "thinking"}` blocks for true extended thinking (use a [pipe function](https://docs.openwebui.com/features/extensibility/plugin/functions/pipe)). | ❌ Not natively supported. |

### Important Notes [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#important-notes "Direct link to Important Notes")

- **Detection is unchanged.** Reasoning is detected from incoming streams the same way it always was: `<think>`-style tag matching for Path 1, `reasoning_content` / `reasoning` / `thinking` deltas for Path 2. The provider-aware behavior added here only governs how Path 2 reasoning is **rebuilt** when the message is replayed.
- **Within-turn vs. cross-turn use the same logic.** The same rebuild rules apply whether Open WebUI is sending the message inside a multi-step tool-call loop or building the payload for a fresh user turn.
- **Most users are on Path 1.** Models that emit `<think>` tags inline (the DeepSeek-R1 family on Ollama, Qwen3, MiniMax M2.5, etc.) keep their reasoning in `content` and continue to round-trip without any provider configuration.

* * *

## Streaming vs Non-Streaming [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#streaming-vs-non-streaming "Direct link to Streaming vs Non-Streaming")

### Streaming Mode (Default) [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#streaming-mode-default "Direct link to Streaming Mode (Default)")

In streaming mode (`stream: true`), Open WebUI processes tokens as they arrive and can detect reasoning blocks in real-time. This generally works well without additional configuration.

### Non-Streaming Mode [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#non-streaming-mode "Direct link to Non-Streaming Mode")

In non-streaming mode (`stream: false`), the entire response is returned at once. **This is where most parsing issues occur** because:

1. The response arrives as a single block of text
2. Without the reasoning parser, no post-processing separates the `<think>` content
3. The raw response is displayed as-is

Important

If you're using non-streaming requests (via API or certain configurations), **the reasoning parser is essential** for proper thinking block separation.

* * *

## API Usage [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#api-usage "Direct link to API Usage")

When using the Open WebUI API with reasoning models:

```
{
  "model": "qwen3:32b",
  "messages": [\
    {"role": "user", "content": "Solve: What is 234 * 567?"}\
  ],
  "stream": true
}
```

**Recommendation:** Use `"stream": true` for the most reliable reasoning block parsing.

* * *

## Troubleshooting [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#troubleshooting "Direct link to Troubleshooting")

### Thinking Content Merged with Final Answer [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#thinking-content-merged-with-final-answer "Direct link to Thinking Content Merged with Final Answer")

**Symptom:** When using a reasoning model, the entire response (including `<think>...</think>` blocks) is displayed as the final answer, instead of being separated into a hidden/collapsible thinking section.

**Example of incorrect display:**

```
<think>
Okay, the user wants a code snippet for a sticky header using CSS and JavaScript.
Let me think about how to approach this.
...
I think that's a solid approach. Let me write the code now.
</think>

Here's a complete code snippet that demonstrates a sticky header using CSS and JavaScript...
```

**Expected behavior:** The thinking content should be hidden or collapsible, with only the final answer visible.

### For Ollama Users [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#for-ollama-users "Direct link to For Ollama Users")

The most common cause is that Ollama is not configured with the correct **reasoning parser**. When running Ollama, you need to specify the `--reasoning-parser` flag to enable proper parsing of thinking blocks.

#### Step 1: Configure the Reasoning Parser [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#step-1-configure-the-reasoning-parser "Direct link to Step 1: Configure the Reasoning Parser")

When starting Ollama, add the `--reasoning-parser` flag:

```
# For DeepSeek-R1 style reasoning (recommended for most models)
ollama serve --reasoning-parser deepseek_r1

# Alternative parsers (if the above doesn't work for your model)
ollama serve --reasoning-parser qwen3
ollama serve --reasoning-parser deepseek_v3
```

Recommended Parser

For most reasoning models, including Qwen3 and DeepSeek variants, use `--reasoning-parser deepseek_r1`. This parser handles the standard `<think>...</think>` format used by most reasoning models.

#### Step 2: Restart Ollama [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#step-2-restart-ollama "Direct link to Step 2: Restart Ollama")

After adding the flag, restart the Ollama service:

```
# Stop Ollama
# On Linux/macOS:
pkill ollama

# On Windows (PowerShell):
Stop-Process -Name ollama -Force

# Start with the reasoning parser
ollama serve --reasoning-parser deepseek_r1
```

#### Step 3: Verify in Open WebUI [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#step-3-verify-in-open-webui "Direct link to Step 3: Verify in Open WebUI")

1. Go to Open WebUI and start a new chat with your reasoning model
2. Ask a question that requires reasoning (e.g., a math problem or logic puzzle)
3. The response should now show the thinking content in a collapsible section

### Available Reasoning Parsers [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#available-reasoning-parsers "Direct link to Available Reasoning Parsers")

| Parser | Description | Use Case |
| --- | --- | --- |
| `deepseek_r1` | DeepSeek R1 format | Most reasoning models, including Qwen3 |
| `deepseek_v3` | DeepSeek V3 format | Some DeepSeek variants |
| `qwen3` | Qwen3-specific format | If `deepseek_r1` doesn't work with Qwen |

### Troubleshooting Checklist [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#troubleshooting-checklist "Direct link to Troubleshooting Checklist")

#### 1\. Verify Ollama Is Running with Reasoning Parser [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#1-verify-ollama-is-running-with-reasoning-parser "Direct link to 1. Verify Ollama Is Running with Reasoning Parser")

Check if Ollama was started with the correct flag:

```
# Check the Ollama process
ps aux | grep ollama
# or on Windows:
Get-Process -Name ollama | Format-List *
```

Look for `--reasoning-parser` in the command line arguments.

#### 2\. Check Model Compatibility [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#2-check-model-compatibility "Direct link to 2. Check Model Compatibility")

Not all models output reasoning in the same format. Verify your model's documentation for:

- What tags it uses for thinking content (e.g., `<think>`, `<reasoning>`, etc.)
- Whether it requires specific prompting to enable thinking mode

#### 3\. Test with Streaming Enabled [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#3-test-with-streaming-enabled "Direct link to 3. Test with Streaming Enabled")

If non-streaming isn't working, try enabling streaming in your chat:

1. Go to **Chat Controls** (sidebar)
2. Ensure streaming is enabled (this is the default)
3. Test the model again

#### 4\. Check Open WebUI Version [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#4-check-open-webui-version "Direct link to 4. Check Open WebUI Version")

Ensure you're running the latest version of Open WebUI, as reasoning model support continues to improve:

```
docker pull ghcr.io/open-webui/open-webui:main
```

#### 5\. Verify the Model Response Format [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#5-verify-the-model-response-format "Direct link to 5. Verify the Model Response Format")

Use the Ollama CLI directly to check what format your model outputs:

```
ollama run your-model:tag "Explain step by step: What is 15 + 27?"
```

Look for `<think>` tags in the output. If they're not present, the model may require specific system prompts to enable thinking mode.

### Reasoning Lost Between Tool Calls [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#reasoning-lost-between-tool-calls "Direct link to Reasoning Lost Between Tool Calls")

**Symptom:** The model seems to "forget" what it was thinking about after a tool call completes.

**Possible Causes:**

1. The model doesn't output reasoning in a captured format (`reasoning_content`, `reasoning`, or `thinking` delta fields)
2. The model uses text-based thinking tags that aren't being parsed as reasoning blocks

**Solution:** Check if your model outputs reasoning through:

- Structured delta fields (`reasoning_content`, `reasoning`, `thinking`)
- Text-based tags that Open WebUI detects (ensure reasoning tag detection is enabled)

### Anthropic Extended Thinking Not Working with Tool Calls [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#anthropic-extended-thinking-not-working-with-tool-calls "Direct link to Anthropic Extended Thinking Not Working with Tool Calls")

**Symptom:** Using Anthropic's Claude models with extended thinking enabled, but tool calls fail with errors like:

```text
Expected `thinking` or `redacted_thinking`, but found `text`. When `thinking` is enabled,
a final `assistant` message must start with a thinking block.
```

**Cause:** This is a fundamental architectural difference. Open WebUI follows the **OpenAI Chat Completions API standard** and does not natively support Anthropic's proprietary API format. Anthropic's extended thinking requires structured content blocks with `{"type": "thinking"}` or `{"type": "redacted_thinking"}`, which are Anthropic-specific formats that don't exist in the OpenAI standard.

Open WebUI serializes reasoning as text wrapped in tags (e.g., `<think>...</think>`) inside the message content field. This works with OpenAI-compatible APIs but does not satisfy Anthropic's requirement for structured thinking blocks.

**Why Open WebUI Doesn't Support This Natively:**

There is no standard way for storing reasoning content as part of the API payload across different providers. If Open WebUI implemented support for one provider's format, it would likely break existing deployments for many other inference providers. Given the wide variety of backends Open WebUI supports, we follow the OpenAI Completions API as the common standard. For more details on this architectural decision, see our **[FAQ on protocol support](https://docs.openwebui.com/faq#q-why-doesnt-open-webui-natively-support-provider-xs-proprietary-api)**.

**Workarounds:**

1. **Use a Pipe Function**: Create a custom [pipe function](https://docs.openwebui.com/features/extensibility/pipelines/pipes) that converts Open WebUI's text-based thinking format to Anthropic's structured thinking blocks before sending requests to the Anthropic API.

2. **Disable Extended Thinking**: If you don't need extended thinking for tool-calling workflows, disable it to avoid the format mismatch.


note

This limitation applies specifically to combining Anthropic's extended thinking with tool calls. Extended thinking works without tool calls, and tool calls work without extended thinking. The issue only occurs when using both features together via the Anthropic API.

### Stateful Reasoning Models (GPT-5.2, etc.) [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#stateful-reasoning-models-gpt-52-etc "Direct link to Stateful Reasoning Models (GPT-5.2, etc.)")

**Symptom:** Using a model that hides its reasoning (stateful/internal reasoning), and reasoning is not being preserved.

**Cause:** Some newer models (like GPT-5.2) keep their reasoning internal and don't expose it in the API response. Open WebUI can only preserve reasoning that is actually returned by the model.

**Behavior:** If the model returns a reasoning summary instead of full reasoning content, that summary is what gets preserved and sent back.

* * *

## Frequently Asked Questions [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#frequently-asked-questions "Direct link to Frequently Asked Questions")

### Why is the thinking block showing as raw text? [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#why-is-the-thinking-block-showing-as-raw-text "Direct link to Why is the thinking block showing as raw text?")

If the model uses tags that are not in the default list and have not been configured in `reasoning_tags`, Open WebUI will treat them as regular text. You can fix this by adding the correct tags to the `reasoning_tags` parameter in the Model Settings or Chat Controls.

### Does the model see its own thinking? [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#does-the-model-see-its-own-thinking "Direct link to Does the model see its own thinking?")

**Yes.** Reasoning content is preserved and sent back to the model in both scenarios:

- **Within the same turn (during tool calls)**: **Yes**. When a model makes tool calls, Open WebUI preserves the reasoning content and sends it back to the API as part of the assistant message. This enables the model to maintain context about what it was thinking when it made the tool call.

- **Across different turns**: **Yes**. When building messages for subsequent requests, Open WebUI serializes reasoning content from previous turns with its original tags (e.g., `<think>...</think>`) and includes it in the assistant message's `content` field. This allows the model to reference its previous reasoning throughout the conversation.


### How is reasoning sent during tool calls? [​](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/\#how-is-reasoning-sent-during-tool-calls "Direct link to How is reasoning sent during tool calls?")

When tool calls are involved, reasoning is serialized as text with its original tags and included in the assistant message's `content` field. For example:

```text
<think>Let me search for the current weather...</think>
```

This text-based format works with most OpenAI-compatible providers. However, some providers (like Anthropic) may expect structured thinking content blocks in a specific format. Open WebUI currently uses text-based serialization rather than provider-specific structured formats.

This content is for informational purposes only and does not constitute a warranty, guarantee, or contractual commitment. Open WebUI is provided "as is." See your [license](https://docs.openwebui.com/license) for applicable terms.

- [How Thinking Tags Work](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#how-thinking-tags-work)
- [The `reasoning_tags` Parameter](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#the-reasoning_tags-parameter)
  - [Default Tags](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#default-tags)
  - [Customization](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#customization)
- [Configuration & Behavior](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#configuration--behavior)
- [Open WebUI Settings](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#open-webui-settings)
  - [Reasoning Tags Setting](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#reasoning-tags-setting)
  - [think (Ollama)](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#think-ollama)
  - [Reasoning Effort](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#reasoning-effort)
- [Interleaved Thinking with Tool Calls](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#interleaved-thinking-with-tool-calls)
  - [How It Works](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#how-it-works)
  - [How Reasoning Is Sent Back](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#how-reasoning-is-sent-back)
  - [Provider Compatibility](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#provider-compatibility)
  - [Important Notes](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#important-notes)
- [Streaming vs Non-Streaming](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#streaming-vs-non-streaming)
  - [Streaming Mode (Default)](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#streaming-mode-default)
  - [Non-Streaming Mode](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#non-streaming-mode)
- [API Usage](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#api-usage)
- [Troubleshooting](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#troubleshooting)
  - [Thinking Content Merged with Final Answer](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#thinking-content-merged-with-final-answer)
  - [For Ollama Users](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#for-ollama-users)
  - [Available Reasoning Parsers](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#available-reasoning-parsers)
  - [Troubleshooting Checklist](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#troubleshooting-checklist)
  - [Reasoning Lost Between Tool Calls](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#reasoning-lost-between-tool-calls)
  - [Anthropic Extended Thinking Not Working with Tool Calls](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#anthropic-extended-thinking-not-working-with-tool-calls)
  - [Stateful Reasoning Models (GPT-5.2, etc.)](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#stateful-reasoning-models-gpt-52-etc)
- [Frequently Asked Questions](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#frequently-asked-questions)
  - [Why is the thinking block showing as raw text?](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#why-is-the-thinking-block-showing-as-raw-text)
  - [Does the model see its own thinking?](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#does-the-model-see-its-own-thinking)
  - [How is reasoning sent during tool calls?](https://docs.openwebui.com/features/chat-conversations/chat-features/reasoning-models/#how-is-reasoning-sent-during-tool-calls)