Sync ollama docs from eab97e9f on 2026-10-12

Sync ollama docs from 53fed261 on 2026-09-12
Sync ollama docs from 948f6933 on 2026-08-12
2026-10-12 04:00:05 +00:00 · 2026-09-12 04:00:05 +00:00 · 2026-08-12 04:00:08 +00:00 · 2026-07-12 04:00:08 +00:00 · 2026-06-12 04:00:06 +00:00
62 changed files with 3362 additions and 1317 deletions
@@ -4,8 +4,8 @@ This is a mirror of the Ollama repository.
 **Synced from:** https://github.com/ollama/ollama.git
 **Branch:** main
-**Commit:** 421faa0263f28499e2ff9076ffca240a8fc262ca
+**Commit:** eab97e9f92b9a25c2d52d2cc6c1b1c99bd9fae21
-**Sync Date:** 2026-05-12
+**Sync Date:** 2026-10-12
 **Content:** Paths: docs
 ---
@@ -19,5 +19,5 @@
 ### Resources
 * [Troubleshooting Guide](https://docs.ollama.com/troubleshooting)
-* [FAQ](https://docs.ollama.com/faq#faq)
+* [FAQ](https://docs.ollama.com/faq)
 * [Development guide](./development.md)
@@ -16,7 +16,6 @@
 - [Generate Embeddings](#generate-embeddings)
 - [List Running Models](#list-running-models)
 - [Version](#version)
 - [Experimental: Image Generation](#image-generation-experimental)
 ## Conventions
@@ -46,7 +45,7 @@ Generate a response for a given prompt with a provided model. This is a streamin
 - `prompt`: the prompt to generate a response for
 - `suffix`: the text after the model response
 - `images`: (optional) a list of base64-encoded images (for multimodal models such as `llava`)
- `think`: (for thinking models) should the model think before responding?
+- `think`: (for thinking models) should the model think before responding? Can be a boolean or a thinking level (`"low"`, `"medium"`, `"high"`, or `"max"`).
 Advanced parameters (optional):
@@ -59,15 +58,6 @@ Advanced parameters (optional):
 - `keep_alive`: controls how long the model will stay loaded into memory following the request (default: `5m`)
 - `context` (deprecated): the context parameter returned from a previous request to `/generate`, this can be used to keep a short conversational memory
 Experimental image generation parameters (for image generation models only):
 > [!WARNING]
 > These parameters are experimental and may change in future versions.
 - `width`: width of the generated image in pixels
 - `height`: height of the generated image in pixels
 - `steps`: number of diffusion steps
 #### Structured outputs
 Structured outputs are supported by providing a JSON schema in the `format` parameter. The model will generate a response that matches the schema. See the [structured outputs](#request-structured-outputs) example below.
@@ -110,7 +100,8 @@ The final response in the stream also includes additional data about the generat
 - `total_duration`: time spent generating the response
 - `load_duration`: time spent in nanoseconds loading the model
 - `prompt_eval_count`: number of tokens in the prompt
- `prompt_eval_duration`: time spent in nanoseconds evaluating the prompt
+- `prompt_eval_cached_count`: number of prompt tokens read from the cache
 - `prompt_eval_duration`: time spent in nanoseconds evaluating uncached prompt tokens
 - `eval_count`: number of tokens in the response
 - `eval_duration`: time in nanoseconds spent generating the response
 - `context`: an encoding of the conversation used in this response, this can be sent in the next request to keep a conversational memory
@@ -387,6 +378,8 @@ curl http://localhost:11434/api/generate -d '{
 If you want to set custom options for the model at runtime rather than in the Modelfile, you can do so with the `options` parameter. This example sets every available option, but you can set any of them individually and omit the ones you do not want to override.
 `typical_p` is deprecated and may be removed in a future release.
 ##### Request
 ```shell
@@ -398,10 +391,10 @@ curl http://localhost:11434/api/generate -d '{
    "num_keep": 5,
    "seed": 42,
    "num_predict": 100,
    "draft_num_predict": 4,
    "top_k": 20,
    "top_p": 0.9,
    "min_p": 0.0,
    "typical_p": 0.7,
    "repeat_last_n": 33,
    "temperature": 0.8,
    "repeat_penalty": 1.2,
@@ -503,7 +496,7 @@ Generate the next message in a chat with a provided model. This is a streaming e
 - `model`: (required) the [model name](#model-names)
 - `messages`: the messages of the chat, this can be used to keep a chat memory
 - `tools`: list of tools in JSON for the model to use if supported
- `think`: (for thinking models) should the model think before responding?
+- `think`: (for thinking models) should the model think before responding? Can be a boolean or a thinking level (`"low"`, `"medium"`, `"high"`, or `"max"`).
 The `message` object has the following fields:
@@ -1186,31 +1179,37 @@ Create a model from:
 - another model;
 - a safetensors directory; or
- a GGUF file.
+- one or more GGUF files.
-If you are creating a model from a safetensors directory or from a GGUF file, you must [create a blob](#create-a-blob) for each of the files and then use the file name and SHA256 digest associated with each blob in the `files` field.
+Use GGUF community tools to prepare and quantize GGUF files before importing.
 If you are creating a model from a safetensors directory or from GGUF files, you must [push a blob](#push-a-blob) for each file and then use its file name and SHA256 digest in the `files` field.
 ### Parameters
 - `model`: name of the model to create
 - `from`: (optional) name of an existing model to create the new model from
 - `files`: (optional) a dictionary of file names to SHA256 digests of blobs to create the model from
 - `adapters`: (optional) a dictionary of file names to SHA256 digests of blobs for LORA adapters
 - `template`: (optional) the prompt template for the model
 - `renderer`: (optional) the name of the renderer for the model
 - `parser`: (optional) the name of the parser for the model
 - `license`: (optional) a string or list of strings containing the license or licenses for the model
 - `system`: (optional) a string containing the system prompt for the model
 - `parameters`: (optional) a dictionary of parameters for the model (see [Modelfile](./modelfile.mdx#valid-parameters-and-values) for a list of parameters)
 - `messages`: (optional) a list of message objects used to create a conversation
 - `capabilities`: (optional) capabilities to add without removing inherited or inferred capabilities, such as `["decision"]` for compatible decision models
 - `stream`: (optional) if `false` the response will be returned as a single response object, rather than a stream of objects
- `quantize` (optional): quantize a non-quantized (e.g. float16) model
+- `quantize`: (optional) quantize safetensors model weights for MLX during import
 #### Quantization types
-| Type   | Recommended |
+| Type  | Recommended |
-| ------ | :---------: |
+| ----- | :---------: |
-| q4_K_M |     \*      |
+| nvfp4 |     \*      |
-| q4_K_S |             |
+| mxfp8 |     \*      |
-| q8_0   |     \*      |
+| mxfp4 |             |
 | int4  |             |
 | int8  |             |
 ### Examples
@@ -1246,40 +1245,9 @@ A stream of JSON objects is returned:
 {"status":"success"}
 ```
 #### Quantize a model
 Quantize a non-quantized model.
 ##### Request
 ```shell
 curl http://localhost:11434/api/create -d '{
  "model": "llama3.2:quantized",
  "from": "llama3.2:3b-instruct-fp16",
  "quantize": "q4_K_M"
 }'
 ```
 ##### Response
 A stream of JSON objects is returned:
 ```json
 {"status":"quantizing F16 model to Q4_K_M","digest":"0","total":6433687776,"completed":12302}
 {"status":"quantizing F16 model to Q4_K_M","digest":"0","total":6433687776,"completed":6433687552}
 {"status":"verifying conversion"}
 {"status":"creating new layer sha256:fb7f4f211b89c6c4928ff4ddb73db9f9c0cfca3e000c3e40d6cf27ddc6ca72eb"}
 {"status":"using existing layer sha256:966de95ca8a62200913e3f8bfbf84c8494536f1b94b49166851e76644e966396"}
 {"status":"using existing layer sha256:fcc5a6bec9daf9b561a68827b67ab6088e1dba9d1fa2a50d7bbcc8384e0a265d"}
 {"status":"using existing layer sha256:a70ff7e570d97baaf4e62ac6e6ad9975e04caa6d900d3742d37698494479e0cd"}
 {"status":"using existing layer sha256:56bb8bd477a519ffa694fc449c2413c6f0e1d3b1c88fa7e3c9d88d3ae49d4dcb"}
 {"status":"writing manifest"}
 {"status":"success"}
 ```
 #### Create a model from GGUF
-Create a model from a GGUF file. The `files` parameter should be filled out with the file name and SHA256 digest of the GGUF file you wish to use. Use [/api/blobs/:digest](#push-a-blob) to push the GGUF file to the server before calling this API.
+Create a model from GGUF files. The `files` parameter should contain the file name and SHA256 digest of each GGUF file. For a split GGUF model, include each shard under its original split filename. Use [/api/blobs/:digest](#push-a-blob) to push each file before calling this API.
 ##### Request
@@ -1305,7 +1273,7 @@ A stream of JSON objects is returned:
 #### Create a model from a Safetensors directory
-The `files` parameter should include a dictionary of files for the safetensors model which includes the file names and SHA256 digest of each file. Use [/api/blobs/:digest](#push-a-blob) to first push each of the files to the server before calling this API. Files will remain in the cache until the Ollama server is restarted.
+The `files` parameter should include the file name and SHA256 digest of each file in the Safetensors model. Use [/api/blobs/:digest](#push-a-blob) to push each file before calling this API. Files remain in the cache until the Ollama server is restarted.
 ##### Request
@@ -1328,11 +1296,8 @@ curl http://localhost:11434/api/create -d '{
 A stream of JSON objects is returned:
 ```shell
-{"status":"converting model"}
+{"status":"importing fred (2 tensors)"}
-{"status":"creating new layer sha256:05ca5b813af4a53d2c2922933936e398958855c44ee534858fcfd830940618b6"}
+{"status":"writing manifest for fred"}
 {"status":"using autodetected template llama3-instruct"}
 {"status":"using existing layer sha256:56bb8bd477a519ffa694fc449c2413c6f0e1d3b1c88fa7e3c9d88d3ae49d4dcb"}
 {"status":"writing manifest"}
 {"status":"success"}
 ```
@@ -1529,6 +1494,12 @@ curl http://localhost:11434/api/copy -d '{
 Returns a 200 OK if successful, or a 404 Not Found if the source model doesn't exist.
 ```json
 {
  "status": "success"
 }
 ```
 ## Delete a Model
 ```
@@ -1703,7 +1674,7 @@ Generate embeddings from a model
 ### Parameters
 - `model`: name of model to generate embeddings from
- `input`: text or list of text to generate embeddings for
+- `input`: text or list of text to generate embeddings for. To embed media (images or audio) alongside text on models that accept multimodal embeddings, each entry may instead be an object with any of `text` (string), `image` (base64-encoded bytes), `audio` (base64-encoded bytes). In a list, entries can mix plain strings and such objects; each object owns its own media. `video` is not currently accepted.
 Advanced parameters:
@@ -1767,6 +1738,28 @@ curl http://localhost:11434/api/embed -d '{
 }
 ```
 #### Request (With image)
 ```shell
 curl http://localhost:11434/api/embed -d '{
  "model": "embeddinggemma2",
  "input": {"text": "a cat sitting on a windowsill", "image": "iVBORw0KGgo..."}
 }'
 ```
 #### Request (Batched, mixed modalities)
 ```shell
 curl http://localhost:11434/api/embed -d '{
  "model": "embeddinggemma2",
  "input": [
    "a plain text query",
    {"image": "iVBORw0KGgo..."},
    {"audio": "UklGRiQAAABXQVZF..."}
  ]
 }'
 ```
 ## List Running Models
 ```
@@ -1877,55 +1870,3 @@ curl http://localhost:11434/api/version
  "version": "0.5.1"
 }
 ```
 ## Experimental Features
 ### Image Generation (Experimental)
 > [!WARNING]
 > Image generation is experimental and may change in future versions.
 Image generation is now supported through the standard `/api/generate` endpoint when using image generation models. The API automatically detects when an image generation model is being used.
 See the [Generate a completion](#generate-a-completion) section for the full API documentation. The experimental image generation parameters (`width`, `height`, `steps`) are documented there.
 #### Example
 ##### Request
 ```shell
 curl http://localhost:11434/api/generate -d '{
  "model": "x/z-image-turbo",
  "prompt": "a sunset over mountains",
  "width": 1024,
  "height": 768
 }'
 ```
 ##### Response (streaming)
 Progress updates during generation:
 ```json
 {
  "model": "x/z-image-turbo",
  "created_at": "2024-01-15T10:30:00.000000Z",
  "completed": 5,
  "total": 20,
  "done": false
 }
 ```
 ##### Final Response
 ```json
 {
  "model": "x/z-image-turbo",
  "created_at": "2024-01-15T10:30:15.000000Z",
  "image": "iVBORw0KGgoAAAANSUhEUg...",
  "done": true,
  "done_reason": "stop",
  "total_duration": 15000000000,
  "load_duration": 2000000000
 }
 ```
@@ -2,9 +2,42 @@
 title: Anthropic compatibility
 ---
-Ollama provides compatibility with the [Anthropic Messages API](https://docs.anthropic.com/en/api/messages) to help connect existing applications to Ollama, including tools like Claude Code.
+Connect Anthropic clients and tools such as Claude Code to Ollama. Ollama supports a subset of the [Anthropic Messages API](https://platform.claude.com/docs/en/api/http/messages/create).
-## Usage
+## Direct cloud access
 Set your [API key](https://ollama.com/settings/keys) in `OLLAMA_API_KEY`. No Ollama installation required.
 ```shell
 export OLLAMA_API_KEY="your_api_key"
 ```
 Send a request with bearer authentication:
 ```shell
 curl https://ollama.com/v1/messages \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "gemma4:31b",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Say hello in one sentence."
      }
    ]
  }'
 ```
 Read text blocks from `content`. The cloud endpoint requires `Authorization: Bearer`; it does not accept `x-api-key` alone.
 Compatible models support messages, streaming, and function calling. Tool-choice controls, deferred tools, and hosted web search are not fully supported.
 ## Local server usage
 These examples connect to your local Ollama server. Use `ollama` as the placeholder API key. To use cloud models through this server, [sign in to Ollama](/api/authentication#signing-in).
 ### Environment variables
@@ -234,55 +267,7 @@ curl -X POST http://localhost:11434/v1/messages \
 ## Using with Claude Code
-[Claude Code](https://code.claude.com/docs/en/overview) can be configured to use Ollama as its backend. 
+See the [Claude Code guide](/integrations/claude-code) for Ollama Launch and [direct cloud setup](/integrations/claude-code#connect-directly-to-ollama-cloud).
 ### Recommended models
 For coding use cases, models like `glm-4.7`, `minimax-m2.1`, and `qwen3-coder` are recommended.
 Download a model before use:
 ```shell
 ollama pull qwen3-coder
 ```
 > Note: Qwen 3 coder is a 30B parameter model requiring at least 24GB of VRAM to run smoothly. More is required for longer context lengths. 
 ```shell
 ollama pull glm-4.7:cloud
 ```
 ### Quick setup
 ```shell
 ollama launch claude
 ```
 This will prompt you to select a model, configure Claude Code automatically, and launch it. To configure without launching:
 ```shell
 ollama launch claude --config
 ```
 ### Manual setup
 Set the environment variables and run Claude Code:
 ```shell
 ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_BASE_URL=http://localhost:11434 claude --model qwen3-coder
 ```
 Or set the environment variables in your shell profile:
 ```shell
 export ANTHROPIC_AUTH_TOKEN=ollama
 export ANTHROPIC_BASE_URL=http://localhost:11434
 ```
 Then run Claude Code with any Ollama model:
 ```shell
 claude --model qwen3-coder
 ```
 ## Endpoints
@@ -318,6 +303,8 @@ claude --model qwen3-coder
 - [x] `stop_sequences`
 - [x] `tools`
 - [x] `thinking`
 - [x] `output_config`
  - [x] `effort` (model-defined names)
 - [ ] `tool_choice`
 - [ ] `metadata`
@@ -342,6 +329,8 @@ claude --model qwen3-coder
 - [x] `ping`
 - [x] `error`
 Use `/api/show` to discover a model's supported thinking values and default. `thinking.type: "enabled"` and `"disabled"` act as explicit on/off controls. When a model uses its metadata to resolve named levels, supported `output_config.effort` names are applied exactly and unsupported names resolve to the model default. Models without metadata keep the existing compatibility behavior, which trims and lowercases effort names and maps `"xhigh"` to `"high"`.
 ## Models
 Ollama supports both local and cloud models.
@@ -360,12 +349,9 @@ Recommended local models:
 ### Cloud models
-Cloud models are available immediately without pulling:
+Browse the [cloud model catalog](https://ollama.com/search?c=cloud). Through a signed-in Ollama server, use a cloud name such as `gemma4:cloud` without a separate pull. For direct cloud requests, use the hosted identifier, such as `gemma4:31b`.
- `glm-4.7:cloud` - High-performance cloud model
+### Default model names on a local server
 - `minimax-m2.1:cloud` - Fast cloud model
 ### Default model names
 For tooling that relies on default Anthropic model names such as `claude-3-5-sonnet`, use `ollama cp` to copy an existing model name:
@@ -394,8 +380,8 @@ curl http://localhost:11434/v1/messages \
 ### Behavior differences
- API key is accepted but not validated
+- The local server does not validate API keys. Direct cloud inference requires a valid bearer token.
- `anthropic-version` header is accepted but not used
+- The hosted endpoint rejects `anthropic-version` values older than `2023-06-01`. Use `2023-06-01` in requests.
 - Token counts are approximations based on the underlying model's tokenizer
 ### Not supported
@@ -2,34 +2,52 @@
 title: Authentication
 ---
-No authentication is required when accessing Ollama's API locally via `http://localhost:11434`.
+The local API at `http://localhost:11434` does not require authentication.
-Authentication is required for the following:
+To use cloud models, publish models, or download private models, sign in to Ollama. For direct API access to ollama.com, use an API key.
-* Running cloud models via ollama.com
+## API keys
 * Publishing models
 * Downloading private models
-Ollama supports two authentication methods:
+Direct cloud inference at `https://ollama.com/api` and `https://ollama.com/v1` requires an API key. No Ollama installation or local server is required.
-* **Signing in**: sign in from your local installation, and Ollama will automatically take care of authenticating requests to ollama.com when running commands
+Create an [API key](https://ollama.com/settings/keys), then set it in your terminal:
-* **API keys**: API keys for programmatic access to ollama.com's API
+
 ```shell
 export OLLAMA_API_KEY="your_api_key"
 ```
 Use the API key in the `Authorization: Bearer` header. This also applies to the hosted Anthropic-compatible `/v1/messages` endpoint; `x-api-key` alone is not supported.
 ```shell
 curl https://ollama.com/api/chat \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:31b",
    "messages": [{"role": "user", "content": "Why is the sky blue?"}],
    "stream": false
  }'
 ```
 API keys do not expire. Revoke a key in [API keys settings](https://ollama.com/settings/keys).
 Keep keys outside browser code and source control. See the [API quickstart](/quickstart#build-an-application) for shell setup and compatibility examples.
 ## Signing in
-To sign in to ollama.com from your local installation of Ollama, run:
+Sign in from your terminal:
 ```
 ollama signin
 ```
-Once signed in, Ollama will automatically authenticate commands as required:
+Ollama then authenticates cloud requests for you:
 ```
 ollama run gpt-oss:120b-cloud
 ```
-Similarly, when accessing a local API endpoint that requires cloud access, Ollama will automatically authenticate the request:
+This also works through the local API:
 ```shell
 curl http://localhost:11434/api/generate -d '{
@@ -37,27 +55,3 @@ curl http://localhost:11434/api/generate -d '{
  "prompt": "Why is the sky blue?"
 }'
 ```
 ## API keys
 For direct access to ollama.com's API served at `https://ollama.com/api`, authentication via API keys is required.
 First, create an [API key](https://ollama.com/settings/keys), then set the `OLLAMA_API_KEY` environment variable:
 ```shell
 export OLLAMA_API_KEY=your_api_key
 ```
 Then use the API key in the Authorization header:
 ```shell
 curl https://ollama.com/api/generate \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -d '{
    "model": "gpt-oss:120b",
    "prompt": "Why is the sky blue?",
    "stream": false
  }'
 ```
 API keys don't currently expire, however you can revoke them at any time in your [API keys settings](https://ollama.com/settings/keys).
@@ -0,0 +1,78 @@
 ---
 title: Balance
 sidebarTitle: /api/balance
 openapi: /openapi.yaml GET /api/balance
 ---
 <RequestExample>
 ```shell Request
 curl https://ollama.com/api/balance \
  -H "Authorization: Bearer $OLLAMA_API_KEY"
 ```
 </RequestExample>
 <ResponseExample>
 ```json Response
 {
  "included": {
    "balance_usd": 72.5,
    "allowance_usd": 100,
    "period": {
      "from": "2026-09-15T09:30:00Z",
      "until": "2026-10-15T09:30:00Z"
    }
  },
  "purchased": {
    "balance_usd": 25
  }
 }
 ```
 </ResponseExample>
 This endpoint takes no query parameters. For usage history, see [Cloud usage](/api/cloud-usage).
 ## Balances
 The included period follows your plan's monthly reset schedule, including for annual subscriptions. Period timestamps are in UTC, with `from` inclusive and `until` exclusive.
 The purchased balance includes only unexpired credits.
 <Accordion title="Legacy plans">
 Plans with session and weekly limits return `session` and `weekly` in `included`:
 ```json
 {
  "included": {
    "session": {
      "remaining_percent": 75,
      "resets_at": "2026-10-01T07:00:00Z"
    },
    "weekly": {
      "remaining_percent": 40,
      "resets_at": "2026-10-05T00:00:00Z"
    }
  },
  "purchased": {
    "balance_usd": 25
  }
 }
 ```
 `remaining_percent` ranges from `0` to `100`; `75` means 75% remains. `resets_at` is the next reset time in UTC.
 </Accordion>
 ## Rate limits
 This endpoint allows 10 requests per minute per user, shared across API keys and devices. We recommend polling once per minute. A `429` response includes a `Retry-After` header with the number of seconds to wait before retrying.
 ## Teams
 All team members share the same included and purchased balances.
 ## Reference
@@ -0,0 +1,120 @@
 ---
 title: Cloud usage
 sidebarTitle: /api/usage
 openapi: /openapi.yaml GET /api/usage
 ---
 <RequestExample>
 ```shell Request
 curl 'https://ollama.com/api/usage?range=24h' \
  -H "Authorization: Bearer $OLLAMA_API_KEY"
 ```
 </RequestExample>
 <ResponseExample>
 ```json Response (22 empty buckets omitted)
 {
  "range": "24h",
  "scope": "self",
  "granularity": "hour",
  "from": "2026-09-30T02:00:00Z",
  "until": "2026-10-01T02:30:00Z",
  "totals": {
    "request_count": 15,
    "usage_usd": 0.01718,
    "input_tokens": 106000,
    "cached_input_tokens": 46000,
    "output_tokens": 13600
  },
  "buckets": [
    {
      "from": "2026-09-30T12:00:00Z",
      "until": "2026-09-30T13:00:00Z",
      "request_count": 4,
      "usage_usd": 0.0052,
      "input_tokens": 24000,
      "cached_input_tokens": 0,
      "output_tokens": 3200
    },
    {
      "from": "2026-10-01T00:00:00Z",
      "until": "2026-10-01T01:00:00Z",
      "request_count": 8,
      "usage_usd": 0.0088,
      "input_tokens": 64000,
      "cached_input_tokens": 40000,
      "output_tokens": 8000
    },
    {
      "from": "2026-10-01T02:00:00Z",
      "until": "2026-10-01T02:30:00Z",
      "partial": true,
      "request_count": 3,
      "usage_usd": 0.00318,
      "input_tokens": 18000,
      "cached_input_tokens": 6000,
      "output_tokens": 2400
    }
  ]
 }
 ```
 </ResponseExample>
 New usage may take time to appear.
 For your remaining included and purchased credits, use [Balance](/api/balance).
 Unsupported or repeated query parameters return `400`. Errors follow Ollama's [JSON error format](/api/errors#error-messages).
 ## Time ranges
 | Range | Starts at                                         | Bucket size | Buckets |
 | ----- | ------------------------------------------------- | ----------- | ------- |
 | `24h` | 24 hours before the start of the current UTC hour | Hour        | 25      |
 | `7d`  | Seven days ago at 00:00 UTC                       | Day         | 8       |
 | `30d` | Thirty days ago at 00:00 UTC                      | Day         | 31      |
 Every range ends at the time of the request. For example, at 02:30 UTC on October 1, `24h` starts at 02:00 UTC on September 30. It returns 24 complete hourly buckets followed by the current 02:00–02:30 bucket. The `7d` and `30d` ranges return seven and thirty complete days, followed by today so far.
 Buckets appear in chronological order, including zeroes for hours or days with no recorded requests. The final bucket covers the current hour or day and has `partial: true`.
 All timestamps are in UTC. Each `from` is inclusive and each `until` is exclusive.
 ## Usage totals and buckets
 `totals` summarizes usage across the entire range. `buckets` breaks that usage into hours or days.
 `granularity` is set automatically: `hour` for `24h` and `day` for `7d` and `30d`. The top-level `from` and `until` describe the entire range; each bucket has its own boundaries.
 `partial` indicates whether the hour or day is still in progress, rather than whether all usage has been recorded.
 <Accordion title="Legacy plans">
 For legacy plans, only request counts are available. If a bucket or total includes legacy requests, cost and token counts are omitted.
 </Accordion>
 ## Rate limits
 This endpoint allows 10 requests per minute per user, shared across API keys and devices. We recommend polling once per minute. A `429` response includes a `Retry-After` header with the number of seconds to wait before retrying.
 ## Team usage
 By default, everyone sees their own usage (`scope=self`).
 Team admins can use `scope=team` to see usage for the whole team:
 ```shell
 curl 'https://ollama.com/api/usage?range=7d&scope=team' \
  -H "Authorization: Bearer $OLLAMA_API_KEY"
 ```
 ## Coming soon
 We plan to add custom time ranges, usage breakdowns by model and API key, and breakdowns by team member for team admins.
 ## Reference
@@ -28,9 +28,9 @@ Errors are returned in the `application/json` format with the following structur
 If an error occurs mid-stream, the error will be returned as an object in the `application/x-ndjson` format with an `error` property. Since the response has already started, the status code of the response will not be changed.
 ```json
-{"model":"gemma3","created_at":"2025-10-26T17:21:21.196249Z","response":" Yes","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:21:21.196249Z","response":" Yes","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:21:21.207235Z","response":".","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:21:21.207235Z","response":".","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:21:21.219166Z","response":"I","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:21:21.219166Z","response":"I","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:21:21.231094Z","response":"can","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:21:21.231094Z","response":"can","done":false}
 {"error":"an error was encountered while running the model"}
 ```
@@ -2,45 +2,55 @@
 title: Introduction
 ---
-Ollama's API allows you to run and interact with models programatically.
+Use Ollama's API to build applications with cloud or local models.
 ## Get started
-If you're just getting started, follow the [quickstart](/quickstart) documentation to get up and running with Ollama's API.
+Call cloud models with an [API key](https://ollama.com/settings/keys). No Ollama installation required. Start with the [API quickstart](/quickstart#build-an-application).
-## Base URL
+To run models on your computer, [install Ollama and run a local model](/quickstart#run-a-model-locally).
-After installation, Ollama's API is served by default at:
+## Base URLs
-```
+| API | Direct cloud access | Local Ollama server |
-http://localhost:11434/api
+| --- | --- | --- |
-```
+| Ollama | `https://ollama.com/api` | `http://localhost:11434/api` |
 | OpenAI compatibility | `https://ollama.com/v1` | `http://localhost:11434/v1` |
 | Anthropic client base URL | `https://ollama.com` | `http://localhost:11434` |
-For running cloud models on **ollama.com**, the same API is available with the following base URL:
+The Anthropic client appends `/v1/messages` to its base URL.
-```
+Cloud requests need an API key. Local requests do not. To use cloud models through your local server, [sign in to Ollama](/api/authentication#signing-in).
 https://ollama.com/api
 ```
-## Example request
+Creating or deleting models requires a local Ollama server. [System One](/capabilities/decision) also requires a local server and is not yet available on Ollama Cloud. For supported API features, see [OpenAI compatibility](/api/openai-compatibility) and [Anthropic compatibility](/api/anthropic-compatibility).
-Once Ollama is running, its API is automatically available and can be accessed via `curl`:
+## Ollama API example
 Set `OLLAMA_API_KEY` to your [API key](https://ollama.com/settings/keys), then call a cloud model:
 ```shell
-curl http://localhost:11434/api/generate -d '{
+curl https://ollama.com/api/chat \
-  "model": "gemma3",
+  -H "Authorization: Bearer $OLLAMA_API_KEY" \
-  "prompt": "Why is the sky blue?"
+  -H "Content-Type: application/json" \
-}'
+  -d '{
    "model": "gemma4:31b",
    "messages": [{"role": "user", "content": "Why is the sky blue?"}],
    "stream": false
  }'
 ```
 Read the answer from `message.content`. For local inference, use `http://localhost:11434/api/chat` with a downloaded model and omit the authorization header.
 ## Libraries
-Ollama has official libraries for Python and JavaScript:
+Use Ollama's official libraries with either a local server or the hosted API:
 - [Python](https://github.com/ollama/ollama-python)
 - [JavaScript](https://github.com/ollama/ollama-js)
-Several community-maintained libraries are available for Ollama. For a full list, see the [Ollama GitHub repository](https://github.com/ollama/ollama?tab=readme-ov-file#libraries-1).
+For direct cloud access, set the host to `https://ollama.com` and supply your API key in the `Authorization: Bearer` header.
 Browse [community libraries](https://github.com/ollama/ollama?tab=readme-ov-file#libraries--sdks).
 ## Versioning
@@ -2,9 +2,43 @@
 title: OpenAI compatibility
 ---
-Ollama provides compatibility with parts of the [OpenAI API](https://platform.openai.com/docs/api-reference) to help connect existing applications to Ollama.
+Connect OpenAI clients to Ollama. Ollama supports a subset of the [OpenAI API](https://platform.openai.com/docs/api-reference).
-## Usage
+## Direct cloud access
 Set your [API key](https://ollama.com/settings/keys) in `OLLAMA_API_KEY`. Install the client with `pip install openai`. No Ollama installation required.
 ```python
 import os
 from openai import OpenAI
 client = OpenAI(
    base_url="https://ollama.com/v1",
    api_key=os.environ["OLLAMA_API_KEY"],
 )
 response = client.chat.completions.create(
    model="gemma4:31b",
    messages=[{"role": "user", "content": "Say hello in one sentence."}],
 )
 print(response.choices[0].message.content)
 ```
 The same client supports stateless Responses requests:
 ```python
 response = client.responses.create(
    model="gemma4:31b",
    input="Say hello in one sentence.",
 )
 print(response.output_text)
 ```
 Choose a [cloud model](https://ollama.com/search?c=cloud). The cloud API does not support stateful Responses, built-in web search through `/v1/responses`, or custom/freeform tool-call replay.
 ## Local server usage
 These examples connect to your local Ollama server. The client requires an API key value, but Ollama ignores it. To use cloud models through this server, [sign in to Ollama](/api/authentication#signing-in).
 ### Simple `/v1/chat/completions` example
@@ -208,14 +242,16 @@ curl -X POST http://localhost:11434/v1/chat/completions \
 - [x] `top_p`
 - [x] `max_tokens`
 - [x] `tools`
- [x] `reasoning_effort` (`"high"`, `"medium"`, `"low"`, `"none"`)
+- [x] `reasoning_effort` (model-defined names and compatibility aliases)
 - [x] `reasoning`
-  - [x] `effort` (`"high"`, `"medium"`, `"low"`, `"none"`)
+  - [x] `effort` (model-defined names and compatibility aliases)
 - [ ] `tool_choice`
 - [ ] `logit_bias`
 - [ ] `user`
 - [ ] `n`
 `reasoning_effort` and `reasoning.effort` control model thinking. Use `/api/show` to discover each model's supported values and default. When a model uses its metadata to resolve named levels, supported names are applied exactly and unsupported names resolve to the model default. Boolean-only models that support enabling thinking map recognized compatibility efforts to `true`, while `"none"` requests `false`. Models without metadata retain the existing compatibility aliases: `"minimal"` maps to `"low"`, and `"xhigh"` or `"ultra"` map to `"max"`. GPT-OSS keeps its existing OpenAI compatibility conversion: `"minimal"` uses `"low"`, `"xhigh"` or `"ultra"` use `"high"`, and `"none"` requests no thinking output.
 ### `/v1/completions`
 #### Supported features
@@ -279,74 +315,9 @@ curl -X POST http://localhost:11434/v1/chat/completions \
 - [x] `dimensions`
 - [ ] `user`
-### `/v1/images/generations` (experimental)
+### Responses API
-> Note: This endpoint is experimental and may change or be removed in future versions.
+`POST /v1/responses`
 Generate images using image generation models.
 <CodeGroup dropdown>
 ```python images.py
 from openai import OpenAI
 client = OpenAI(
    base_url='http://localhost:11434/v1/',
    api_key='ollama',  # required but ignored
 )
 response = client.images.generate(
    model='x/z-image-turbo',
    prompt='A cute robot learning to paint',
    size='1024x1024',
    response_format='b64_json',
 )
 print(response.data[0].b64_json[:50] + '...')
 ```
 ```javascript images.js
 import OpenAI from "openai";
 const openai = new OpenAI({
  baseURL: "http://localhost:11434/v1/",
  apiKey: "ollama", // required but ignored
 });
 const response = await openai.images.generate({
  model: "x/z-image-turbo",
  prompt: "A cute robot learning to paint",
  size: "1024x1024",
  response_format: "b64_json",
 });
 console.log(response.data[0].b64_json.slice(0, 50) + "...");
 ```
 ```shell images.sh
 curl -X POST http://localhost:11434/v1/images/generations \
 -H "Content-Type: application/json" \
 -d '{
  "model": "x/z-image-turbo",
  "prompt": "A cute robot learning to paint",
  "size": "1024x1024",
  "response_format": "b64_json"
 }'
 ```
 </CodeGroup>
 #### Supported request fields
 - [x] `model`
 - [x] `prompt`
 - [x] `size` (e.g. "1024x1024")
 - [x] `response_format` (only `b64_json` supported)
 - [ ] `n`
 - [ ] `quality`
 - [ ] `style`
 - [ ] `user`
 ### `/v1/responses`
 > Note: Added in Ollama v0.13.3
@@ -369,19 +340,24 @@ Ollama supports the [OpenAI Responses API](https://platform.openai.com/docs/api-
 - [x] `temperature`
 - [x] `top_p`
 - [x] `max_output_tokens`
 - [x] `reasoning`
  - [x] `effort` (model-defined names and compatibility aliases)
 - [x] `think` (Ollama extension; boolean, model-defined string, or `null`)
 - [ ] `previous_response_id` (stateful v1/responses not supported)
 - [ ] `conversation` (stateful v1/responses not supported)
 - [ ] `truncation`
 ## Models
-Before using a model, pull it locally `ollama pull`:
+For local inference, download a model before using it:
 ```shell
 ollama pull llama3.2
 ```
-### Default model names
+Direct cloud requests use the identifiers from `https://ollama.com/api/tags` and do not require a pull. Through a signed-in local server, select a cloud model such as `gemma4:cloud`.
 ### Default model names on a local server
 For tooling that relies on default OpenAI model names such as `gpt-3.5-turbo`, use `ollama cp` to copy an existing model name to a temporary name:
@@ -405,7 +381,7 @@ curl http://localhost:11434/v1/chat/completions \
    }'
 ```
-### Setting the context size
+### Setting the local context size
 The OpenAI API does not have a way of setting the context size for a model. If you need to change the context size, create a `Modelfile` which looks like:
@@ -5,13 +5,13 @@ title: Streaming
 Certain API endpoints stream responses by default, such as `/api/generate`. These responses are provided in the newline-delimited JSON format (i.e. the `application/x-ndjson` content type). For example:
 ```json
-{"model":"gemma3","created_at":"2025-10-26T17:15:24.097767Z","response":"That","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.097767Z","response":"That","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:15:24.109172Z","response":"'","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.109172Z","response":"'","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:15:24.121485Z","response":"s","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.121485Z","response":"s","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:15:24.132802Z","response":" a","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.132802Z","response":" a","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:15:24.143931Z","response":" fantastic","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.143931Z","response":" fantastic","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:15:24.155176Z","response":" question","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.155176Z","response":" question","done":false}
-{"model":"gemma3","created_at":"2025-10-26T17:15:24.166576Z","response":"!","done":true, "done_reason": "stop"}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.166576Z","response":"!","done":true, "done_reason": "stop"}
 ```
 ## Disabling streaming
@@ -19,7 +19,7 @@ Certain API endpoints stream responses by default, such as `/api/generate`. Thes
 Streaming can be disabled by providing `{"stream": false}` in the request body for any endpoint that support streaming. This will cause responses to be returned in the `application/json` format instead:
 ```json
-{"model":"gemma3","created_at":"2025-10-26T17:15:24.166576Z","response":"That's a fantastic question!","done":true}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.166576Z","response":"That's a fantastic question!","done":true}
 ```
 ## When to use streaming vs non-streaming
@@ -6,8 +6,9 @@ Ollama's API responses include metrics that can be used for measuring performanc
 * `total_duration`: How long the response took to generate
 * `load_duration`: How long the model took to load
-* `prompt_eval_count`: How many input tokens were processed
+* `prompt_eval_count`: How many input tokens were in the prompt
-* `prompt_eval_duration`: How long it took to evaluate the prompt
+* `prompt_eval_cached_count`: How many prompt tokens were read from the cache
 * `prompt_eval_duration`: How long it took to evaluate the uncached prompt tokens
 * `eval_count`: How many output tokens were processes
 * `eval_duration`: How long it took to generate the output tokens
@@ -19,7 +20,7 @@ For endpoints that return usage metrics, the response body will include the usag
 ```json
 {
-  "model": "gemma3",
+  "model": "gemma4",
  "created_at": "2025-10-17T23:14:07.414671Z",
  "response": "Hello! How can I help you today?",
  "done": true,
@@ -27,6 +28,7 @@ For endpoints that return usage metrics, the response body will include the usag
  "total_duration": 174560334,
  "load_duration": 101397084,
  "prompt_eval_count": 11,
  "prompt_eval_cached_count": 8,
  "prompt_eval_duration": 13074791,
  "eval_count": 18,
  "eval_duration": 52479709
@@ -0,0 +1,165 @@
 ---
 title: Decision
 description: Classify text, estimate yes/no probabilities, and score ordered criteria.
 ---
 <Note>
 Currently available locally in Ollama.
 </Note>
 Use System One to classify text, answer yes/no questions, or score text against a rubric.
 See the [full list of decision models](https://ollama.com/search?c=decision).
 ## Setup
 Start [Ollama](/quickstart) v0.35.0 or later, then download [Nimble](https://ollama.com/library/nimble):
 ```shell setup.sh
 ollama pull nimble
 ```
 Nimble, Tev1, [Clef](https://ollama.com/library/clef), and [Clef Flash](https://ollama.com/library/clef-flash) are decision models. The Clef models can also judge images and require v0.35.1 or later.
 Local requests do not need an API key.
 ## Choose a label
 Put your input in `state` and describe the possible answers in `criteria`:
 ```shell choice.sh
 curl http://localhost:11434/v1/systemone \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "nimble",
    "state": "Our checkout has returned 500 errors since 9am.",
    "questions": {
      "label": {
        "type": "choice",
        "instructions": "Which label fits this ticket?",
        "criteria": {
          "billing": "Payments and refunds",
          "bug": "Software errors",
          "account": "Login and account access"
        }
      }
    }
  }'
 ```
 Example response:
 ```json
 {
  "model": "nimble",
  "answers": {
    "label": {
      "type": "choice",
      "choice": "bug",
      "probabilities": {"billing": 0.0125, "bug": 0.9781, "account": 0.0093},
      "confidence": 0.8906
    }
  },
  "usage": {"input_tokens": 174, "output_tokens": 1}
 }
 ```
 ## Judge an image
 [Clef](https://ollama.com/library/clef) and [Clef Flash](https://ollama.com/library/clef-flash) read images alongside the state. Send base64-encoded PNG, JPEG, or WebP files in `images`; they are shared by all questions, in request order. URLs and data URLs are not accepted. `state` is still required — it holds the context for the decision.
 ```shell image.sh
 curl http://localhost:11434/v1/systemone \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "clef-flash",
    "state": "A user took this screenshot and wants to know what it shows.",
    "images": ["<base64-encoded image>"],
    "questions": {
      "has_ollama": {
        "type": "noul",
        "instructions": "Does this image contain Ollama?"
      },
      "app": {
        "type": "choice",
        "instructions": "Which application is shown in this screenshot?",
        "criteria": {
          "vscode": "Visual Studio Code",
          "terminal": "A terminal emulator",
          "browser": "A web browser",
          "other": "A different application"
        }
      }
    }
  }'
 ```
 Example response:
 ```json
 {
  "model": "clef-flash",
  "answers": {
    "has_ollama": {"type": "noul", "noul": 0.959},
    "app": {
      "type": "choice",
      "choice": "vscode",
      "probabilities": {"vscode": 0.966, "other": 0.017, "browser": 0.010, "terminal": 0.007},
      "confidence": 0.868
    }
  },
  "usage": {"input_tokens": 677, "output_tokens": 0}
 }
 ```
 ## Question types
 | Type | Criteria | Result |
 | --- | --- | --- |
 | `choice` | 2–26 named options with descriptions | The most likely option and each option's probability |
 | `noul` | Descriptions for `"false"` and `"true"` | The probability of `true`, from 0 to 1 |
 | `score` | 2–26 descriptions, ordered from lowest to highest | The probability-weighted average of the zero-based levels |
 For the urgency criteria below:
 ```text
 score = 0 × P(Routine) + 1 × P(Soon) + 2 × P(Immediate)
 ```
 For `choice` and `score`, `confidence` measures how strongly the model favors one answer over the others, from 0 to 1. A higher value does not guarantee the answer is correct.
 ## Ask multiple questions
 Combine question types in one request. Here, both questions use the same ticket:
 ```shell multiple.sh
 curl http://localhost:11434/v1/systemone \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "nimble",
    "state": {"ticket": "I was charged twice. Please refund the extra payment."},
    "questions": {
      "refund": {
        "type": "noul",
        "instructions": "Is the customer requesting a refund?",
        "criteria": {
          "false": "No refund is requested",
          "true": "The customer requests a refund"
        }
      },
      "urgency": {
        "type": "score",
        "instructions": "How urgently does this ticket need a response?",
        "criteria": [
          "Routine: no time pressure",
          "Soon: a customer is inconvenienced",
          "Immediate: a critical service is unavailable"
        ]
      }
    }
  }'
 ```
 This returns a refund probability of `0.9989` and an urgency score of `0.8308` on the 0–2 scale (rounded). Results can vary with the model and configuration.
 See the [API reference](/api/systemone) for request fields, limits, errors, and token usage.
@@ -100,12 +100,11 @@ Provide a JSON schema to the `format` field.
    ```
  </Tab>
  <Tab title="JavaScript">
-    Serialize a Zod schema with `zodToJsonSchema()` and parse the structured response:
+    Serialize a Zod schema with `z.toJSONSchema()` and parse the structured response:
    ```javascript
    import ollama from 'ollama'
-    import { z } from 'zod'
+    import * as z from 'zod'
    import { zodToJsonSchema } from 'zod-to-json-schema'
    const Country = z.object({
      name: z.string(),
@@ -116,7 +115,7 @@ Provide a JSON schema to the `format` field.
    const response = await ollama.chat({
      model: 'gpt-oss',
      messages: [{ role: 'user', content: 'Tell me about Canada.' }],
-      format: zodToJsonSchema(Country),
+      format: z.toJSONSchema(Country),
    })
    const country = Country.parse(JSON.parse(response.message.content))
@@ -177,7 +176,7 @@ class ImageDescription(BaseModel):
  text_content: Optional[str] = None
 response = chat(
-  model='gemma3',
+  model='gemma4',
  messages=[{
    'role': 'user',
    'content': 'Describe this photo and list the objects you detect.',
@@ -6,21 +6,46 @@ Thinking-capable models emit a `thinking` field that separates their reasoning t
 Use this capability to audit model steps, animate the model *thinking* in a UI, or hide the trace entirely when you only need the final response.
-## Supported models
+See the [full list of thinking models](https://ollama.com/search?c=thinking).
- [Qwen 3](https://ollama.com/library/qwen3)
+## Discover a model's thinking controls
- [GPT-OSS](https://ollama.com/library/gpt-oss) *(use `think` levels: `low`, `medium`, `high` — the trace cannot be fully disabled)*
+
- [DeepSeek-v3.1](https://ollama.com/library/deepseek-v3.1)
+Thinking controls vary by model. Use `/api/show` to discover the values a model supports and the value Ollama uses by default:
- [DeepSeek R1](https://ollama.com/library/deepseek-r1)
+
- Browse the latest additions under [thinking models](https://ollama.com/search?c=thinking)
+```shell
 curl http://localhost:11434/api/show -d '{
  "model": "gpt-oss"
 }'
 ```
 The response includes a top-level `thinking` object:
 ```json
 {
  "thinking": {
    "values": ["low", "medium", "high"],
    "default": "medium"
  }
 }
 ```
 - `values` can contain booleans (`true` or `false`) for on/off controls. It can also contain model-defined strings for named levels.
 - `default` is used when `think` is not set.
 - `values: [false]` means the model does not support thinking.
 - If `thinking` is omitted, the model has no thinking metadata. The model might conduct thinking based on its existing behavior.
 ## Enable thinking in API calls
-Set the `think` field on chat or generate requests. Most models accept booleans (`true`/`false`).
+Set the `think` field on a chat or generate request:
-GPT-OSS instead expects one of `low`, `medium`, or `high` to tune the trace length. 
+- `true`: request thinking output.
 - `false`: request no thinking output, if the model permits it.
 - `null`: use the model default.
 - A string: select a supported level from `thinking.values`. Use the exact value from `/api/show`. Numbers are not supported.
-The `message.thinking` (chat endpoint) or `thinking` (generate endpoint) field contains the reasoning trace while `message.content` / `response` holds the final answer.
+If the model resolves named levels from `/api/show` metadata, Ollama applies supported names exactly. Unsupported names use the model default. 
 The reasoning output and answer use separate fields. Chat returns `message.thinking` and `message.content`. Generate returns `thinking` and `response`.
 <Tabs>
  <Tab title="cURL">
@@ -68,10 +93,6 @@ The `message.thinking` (chat endpoint) or `thinking` (generate endpoint) field c
  </Tab>
 </Tabs>
 <Note>
  GPT-OSS requires `think` to be set to `"low"`, `"medium"`, or `"high"`. Passing `true`/`false` is ignored for that model.
 </Note>
 ## Stream the reasoning trace
 Thinking streams interleave reasoning tokens before answer tokens. Detect the first `thinking` chunk to render a "thinking" section, then switch to the final reply once `message.content` arrives.
@@ -141,13 +162,3 @@ Thinking streams interleave reasoning tokens before answer tokens. Detect the fi
    ```
  </Tab>
 </Tabs>
 ## CLI quick reference
 - Enable thinking for a single run: `ollama run deepseek-r1 --think "Where should I visit in Lisbon?"`
 - Disable thinking: `ollama run deepseek-r1 --think=false "Summarize this article"`
 - Hide the trace while still using a thinking model: `ollama run deepseek-r1 --hidethinking "Is 9.9 bigger or 9.11?"`
 - Inside interactive sessions, toggle with `/set think` or `/set nothink`.
 - GPT-OSS only accepts levels: `ollama run gpt-oss --think=low "Draft a headline"` (replace `low` with `medium` or `high` as needed).
 <Note>Thinking is enabled by default in the CLI and API for supported models.</Note>
@@ -7,7 +7,7 @@ Vision models accept images alongside text so the model can describe, classify,
 ## Quick start
 ```shell
-ollama run gemma3 ./image.png whats in this image?
+ollama run gemma4 ./image.png what is in this image?
 ```
@@ -28,7 +28,7 @@ Provide an `images` array. SDKs accept file paths, URLs or raw bytes while the R
    curl -X POST http://localhost:11434/api/chat \
    -H "Content-Type: application/json" \
    -d '{
-        "model": "gemma3",
+        "model": "gemma4",
        "messages": [{
        "role": "user",
        "content": "What is in this image?",
@@ -52,7 +52,7 @@ Provide an `images` array. SDKs accept file paths, URLs or raw bytes while the R
    # img = Path(path).read_bytes()
    response = chat(
-      model='gemma3',
+      model='gemma4',
      messages=[
        {
          'role': 'user',
@@ -71,7 +71,7 @@ Provide an `images` array. SDKs accept file paths, URLs or raw bytes while the R
    const imagePath = '/absolute/path/to/image.jpg'
    const response = await ollama.chat({
-      model: 'gemma3',
+      model: 'gemma4',
      messages: [
        { role: 'user', content: 'What is in this image?', images: [imagePath] }
      ],
@@ -5,7 +5,7 @@ title: CLI Reference
 ### Run a model
 ```
-ollama run gemma3
+ollama run gemma4
 ```
 ### Launch integrations
@@ -64,7 +64,7 @@ I'm a basic program that prints the famous "Hello, world!" message to the consol
 #### Multimodal models
 ```
-ollama run gemma3 "What's in this image? /Users/jmorgan/Desktop/smile.png"
+ollama run gemma4 "What's in this image? /Users/jmorgan/Desktop/smile.png"
 ```
 ### Generate embeddings
@@ -82,13 +82,13 @@ echo "Hello world" | ollama run nomic-embed-text
 ### Download a model
 ```
-ollama pull gemma3
+ollama pull gemma4
 ```
 ### Remove a model
 ```
-ollama rm gemma3
+ollama rm gemma4
 ```
 ### List models
@@ -114,7 +114,7 @@ ollama signout
 First, create a `Modelfile`
 ```
-FROM gemma3
+FROM gemma4
 SYSTEM """You are a happy cat."""
 ```
@@ -133,7 +133,7 @@ ollama ps
 ### Stop a running model
 ```
-ollama stop gemma3
+ollama stop gemma4
 ```
 ### Start Ollama
@@ -3,230 +3,90 @@ title: Cloud
 sidebarTitle: Cloud
 ---
-## Cloud Models
+Run models in Ollama's cloud from your apps or terminal. No model or app download required.
-Ollama's cloud models are a new kind of model in Ollama that can run without a powerful GPU. Instead, cloud models are automatically offloaded to Ollama's cloud service while offering the same capabilities as local models, making it possible to keep using your local tools while running larger models that wouldn't fit on a personal computer.
+## API Key
-### Supported models
+Create an [API key](https://ollama.com/settings/keys), then set it in Bash or Zsh:
-For a list of supported models, see Ollama's [model library](https://ollama.com/search?c=cloud).
+```shell
-
+export OLLAMA_API_KEY="your_api_key"
 ### Running Cloud models
 Ollama's cloud models require an account on [ollama.com](https://ollama.com). To sign in or create an account, run:
 ```
 ollama signin
 ```
-<Tabs>
+Send a request from the same terminal:
  <Tab title="CLI">
-To run a cloud model, open the terminal and run:
+```shell
 ```
 ollama run gpt-oss:120b-cloud
 ```
  </Tab>
  <Tab title="Python">
 First, pull a cloud model so it can be accessed:
 ```
 ollama pull gpt-oss:120b-cloud
 ```
 Next, install [Ollama's Python library](https://github.com/ollama/ollama-python):
 ```
 pip install ollama
 ```
 Next, create and run a simple Python script:
 ```python
 from ollama import Client
 client = Client()
 messages = [
  {
    'role': 'user',
    'content': 'Why is the sky blue?',
  },
 ]
 for part in client.chat('gpt-oss:120b-cloud', messages=messages, stream=True):
  print(part['message']['content'], end='', flush=True)
 ```
  </Tab>
  <Tab title="JavaScript">
 First, pull a cloud model so it can be accessed:
 ```
 ollama pull gpt-oss:120b-cloud
 ```
 Next, install [Ollama's JavaScript library](https://github.com/ollama/ollama-js):
 ```
 npm i ollama
 ```
 Then use the library to run a cloud model:
 ```typescript
 import { Ollama } from "ollama";
 const ollama = new Ollama();
 const response = await ollama.chat({
  model: "gpt-oss:120b-cloud",
  messages: [{ role: "user", content: "Explain quantum computing" }],
  stream: true,
 });
 for await (const part of response) {
  process.stdout.write(part.message.content);
 }
 ```
  </Tab>
  <Tab title="cURL">
 First, pull a cloud model so it can be accessed:
 ```
 ollama pull gpt-oss:120b-cloud
 ```
 Run the following cURL command to run the command via Ollama's API:
 ```
 curl http://localhost:11434/api/chat -d '{
  "model": "gpt-oss:120b-cloud",
  "messages": [{
    "role": "user",
    "content": "Why is the sky blue?"
  }],
  "stream": false
 }'
 ```
  </Tab>
 </Tabs>
 ## Cloud API access
 Cloud models can also be accessed directly on ollama.com's API. In this mode, ollama.com acts as a remote Ollama host.
 ### Authentication
 For direct access to ollama.com's API, first create an [API key](https://ollama.com/settings/keys).
 Then, set the `OLLAMA_API_KEY` environment variable to your API key.
 ```
 export OLLAMA_API_KEY=your_api_key
 ```
 ### Listing models
 For models available directly via Ollama's API, models can be listed via:
 ```
 curl https://ollama.com/api/tags
 ```
 ### Generating a response
 <Tabs>
  <Tab title="Python">
 First, install [Ollama's Python library](https://github.com/ollama/ollama-python)
 ```
 pip install ollama
 ```
 Then make a request
 ```python
 import os
 from ollama import Client
 client = Client(
    host="https://ollama.com",
    headers={'Authorization': 'Bearer ' + os.environ.get('OLLAMA_API_KEY')}
 )
 messages = [
  {
    'role': 'user',
    'content': 'Why is the sky blue?',
  },
 ]
 for part in client.chat('gpt-oss:120b', messages=messages, stream=True):
  print(part['message']['content'], end='', flush=True)
 ```
  </Tab>
  <Tab title="JavaScript">
 First, install [Ollama's JavaScript library](https://github.com/ollama/ollama-js):
 ```
 npm i ollama
 ```
 Next, make a request to the model:
 ```typescript
 import { Ollama } from "ollama";
 const ollama = new Ollama({
  host: "https://ollama.com",
  headers: {
    Authorization: "Bearer " + process.env.OLLAMA_API_KEY,
  },
 });
 const response = await ollama.chat({
  model: "gpt-oss:120b",
  messages: [{ role: "user", content: "Explain quantum computing" }],
  stream: true,
 });
 for await (const part of response) {
  process.stdout.write(part.message.content);
 }
 ```
  </Tab>
  <Tab title="cURL">
 Generate a response via Ollama's chat API:
 ```
 curl https://ollama.com/api/chat \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
-    "model": "gpt-oss:120b",
+    "model": "gemma4:31b",
-    "messages": [{
+    "messages": [
-      "role": "user",
+      {
-      "content": "Why is the sky blue?"
+        "role": "user",
-    }],
+        "content": "Say hello in one sentence."
      }
    ],
    "stream": false
  }'
 ```
-  </Tab>
+Read the answer from `message.content`. Keep your API key out of browser code and source control.
 </Tabs>
-## Local only
+You can also use [OpenAI](/api/openai-compatibility) or [Anthropic](/api/anthropic-compatibility) clients. Each supports a subset of the original API. No Ollama installation is required.
-Ollama can run in local-only mode by [disabling Ollama's cloud](./faq#how-do-i-disable-ollama-cloud) features.
+## Ollama App or CLI
 [Download Ollama](https://ollama.com/download). Open the app, or run:
 ```shell
 ollama
 ```
 Follow the setup prompts and sign in to use cloud models.
 On macOS, open **Apps** and connect Claude or ChatGPT. For coding agents, run a launch command:
 <CodeGroup>
 ```shell Claude Code
 ollama launch claude
 ```
 ```shell Codex CLI
 ollama launch codex
 ```
 ```shell OpenCode
 ollama launch opencode
 ```
 </CodeGroup>
 For more integrations, open the Ollama app or run `ollama` in your terminal.
 Ollama handles sign-in for connected apps. See the [quickstart](/quickstart) for setup.
 ## Models
 Browse [cloud models](https://ollama.com/search?c=cloud), or list them with the API:
 ```shell
 curl https://ollama.com/api/tags
 ```
 For API requests to ollama.com, use the name returned by this list, such as `gemma4:31b`. In the Ollama app or CLI, use `gemma4:cloud`. Cloud models do not need to be downloaded.
 ## Usage
 Check your [usage](https://ollama.com/settings/usage) or compare [plans](https://ollama.com/pricing).
 ## Retirements
 [Usage settings](https://ollama.com/settings) show upcoming retirements for models you've recently used. Switch models before the retirement date. Downloaded local models are not affected.
 ## Data handling
 Ollama processes cloud prompts and responses to answer your requests. We do not use them to train models. Read the [Privacy Policy](https://ollama.com/privacy) for details.
 To use only local models, [disable cloud features](/faq#how-do-i-disable-ollama-cloud-features).
@@ -37,5 +37,5 @@ ollama ps
 ```
 ```
 NAME             ID              SIZE      PROCESSOR    CONTEXT    UNTIL
-gemma3:latest    a2af6cc3eb7f    6.6 GB    100% GPU     65536      2 minutes from now
+gemma4:latest    c6eb396dbd59    9.6 GB    100% GPU     131072     2 minutes from now
 ```
@@ -3,9 +3,11 @@
 Install prerequisites:
 - [Go](https://go.dev/doc/install)
- C/C++ Compiler e.g. Clang on macOS, [TDM-GCC](https://github.com/jmeubank/tdm-gcc/releases/latest) (Windows amd64) or [llvm-mingw](https://github.com/mstorsjo/llvm-mingw) (Windows arm64), GCC/Clang on Linux.
+- [CMake](https://cmake.org/download/) 3.24 or newer
 - C/C++ compiler: Clang on macOS, Visual Studio 2022 C++ tools on Windows, or GCC/Clang on Linux
 - [Ninja](https://github.com/ninja-build/ninja/releases) in `PATH` is recommended, especially on Windows
-Then build and run Ollama from the root directory of the repository:
+For pure Go iteration against an existing native payload, run Ollama from the repository root:
 ```shell
 go run . serve
@@ -14,53 +16,73 @@ go run . serve
 > [!NOTE]
 > Ollama includes native code compiled with CGO.  From time to time these data structures can change and CGO can get out of sync resulting in unexpected crashes.  You can force a full build of the native code by running `go clean -cache` first. 
 ## Native build model
 For a fresh checkout, or after changing native code, build from the repository root. On macOS arm64, this builds Metal inference. On all other platforms this builds CPU-only inference. It builds the Go binary at the repository root and installs the native runtime payload under `build/lib/ollama`.
 ```shell
 cmake -B build .
 cmake --build build --parallel 8
 ./ollama serve
 ```
 To install into a standard prefix layout:
 ```shell
 cmake --install build --prefix /path/to/install
 ```
 On all platforms except macOS arm64, to build GPU backends select the backends explicitly:
 ```shell
 cmake -B build . -DOLLAMA_LLAMA_BACKENDS="cuda_v13;vulkan"
 cmake --build build --parallel 8
 ```
 Supported backend values are `cuda_v12`, `cuda_v13`, `rocm_v7_1`, `rocm_v7_2`, `vulkan`, `cuda_jetpack5`, and `cuda_jetpack6`.
 Use standard CMake architecture overrides to narrow GPU builds for local hardware:
 ```shell
 # CUDA
 cmake -B build . -DOLLAMA_LLAMA_BACKENDS=cuda_v13 -DCMAKE_CUDA_ARCHITECTURES=native
 # ROCm / HIP
 cmake -B build . -DOLLAMA_LLAMA_BACKENDS=rocm_v7_2 -DCMAKE_HIP_ARCHITECTURES=gfx1100
 ```
 You can tune GGML build options by setting `GGML_*` values during configure. For example, to disable CUDA flash attention kernels for local debugging:
 ```shell
 cmake -B build . -DOLLAMA_LLAMA_BACKENDS=cuda_v12 -DGGML_CUDA_FA=OFF
 ```
 ## macOS (Apple Silicon)
-macOS Apple Silicon supports Metal which is built-in to the Ollama binary. No additional steps are required.
+Additional prerequisites:
-## macOS (Intel)
+MLX Metal requires the Metal toolchain. Install [Xcode](https://developer.apple.com/xcode/) first, then:
 Install prerequisites:
 - [CMake](https://cmake.org/download/) or `brew install cmake`
 Then, configure and build the project:
 ```shell
-cmake -B build
+xcodebuild -downloadComponent MetalToolchain
 cmake --build build
 ```
 Lastly, run Ollama:
 ```shell
 go run . serve
 ```
 ## Windows
-Install prerequisites:
+Additional prerequisites:
 - [CMake](https://cmake.org/download/)
 - [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) including the Native Desktop Workload
 - (Optional) AMD GPU support
    - [ROCm](https://rocm.docs.amd.com/en/latest/)
    - [Ninja](https://github.com/ninja-build/ninja/releases)
 - (Optional) NVIDIA GPU support
-    - [CUDA SDK](https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=11&target_type=exe_network)
+    - [CUDA SDK](https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_type=exe_network)
- (Optional) VULKAN GPU support
+- (Optional) Vulkan GPU support
-    - [VULKAN SDK](https://vulkan.lunarg.com/sdk/home) - useful for AMD/Intel GPUs
+    - [Vulkan SDK](https://vulkan.lunarg.com/sdk/home) - useful for AMD/Intel GPUs
 - (Optional) MLX engine support
    - [CUDA 13+ SDK](https://developer.nvidia.com/cuda-downloads)
    - [cuDNN 9+](https://developer.nvidia.com/cudnn)
-Then, configure and build the project:
+For Ninja builds, run CMake from a Developer PowerShell/Command Prompt or another shell where the Visual Studio compiler is available.
 ```shell
 cmake -B build
 cmake --build build --config Release
 ```
 > Building for Vulkan requires VULKAN_SDK environment variable:
 > 
@@ -73,36 +95,20 @@ cmake --build build --config Release
 > set VULKAN_SDK=C:\VulkanSDK\<version>
 > ```
 > [!IMPORTANT]
 > Building for ROCm requires additional flags:
 > ```
 > cmake -B build -G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
 > cmake --build build --config Release
 > ```
 Lastly, run Ollama:
 ```shell
 go run . serve
 ```
 ## Windows (ARM)
-Windows ARM does not support additional acceleration libraries at this time.  Do not use cmake, simply `go run` or `go build`.
+Windows ARM does not support additional acceleration libraries at this time.
 ## Linux
-Install prerequisites:
+Additional prerequisites:
 - [CMake](https://cmake.org/download/) or `sudo apt install cmake` or `sudo dnf install cmake`
 - (Optional) AMD GPU support
    - [ROCm](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/install/quick-start.html)
 - (Optional) NVIDIA GPU support
    - [CUDA SDK](https://developer.nvidia.com/cuda-downloads)
- (Optional) VULKAN GPU support
+- (Optional) Vulkan GPU support
-    - [VULKAN SDK](https://vulkan.lunarg.com/sdk/home) - useful for AMD/Intel GPUs
+    - [Vulkan SDK](https://vulkan.lunarg.com/sdk/home) - useful for AMD/Intel GPUs
    - Or install via package manager: `sudo apt install vulkan-sdk` (Ubuntu/Debian) or `sudo dnf install vulkan-sdk` (Fedora/CentOS)
 - (Optional) MLX engine support
    - [CUDA 13+ SDK](https://developer.nvidia.com/cuda-downloads)
@@ -111,57 +117,17 @@ Install prerequisites:
 > [!IMPORTANT]
 > Ensure prerequisites are in `PATH` before running CMake.
 Then, configure and build the project:
 ```shell
 cmake -B build
 cmake --build build
 ```
 Lastly, run Ollama:
 ```shell
 go run . serve
 ```
 ## MLX Engine (Optional)
-The MLX engine enables running safetensor based models. It requires building the [MLX](https://github.com/ml-explore/mlx) and [MLX-C](https://github.com/ml-explore/mlx-c) shared libraries separately via CMake.  On MacOS, MLX leverages the Metal library to run on the GPU, and on Windows and Linux, runs on NVIDIA GPUs via CUDA v13.
+The MLX engine enables running safetensor based models. On macOS arm64, MLX is enabled by default. On other platforms, MLX backends are selected with `OLLAMA_MLX_BACKENDS`.
-### macOS (Apple Silicon)
+### CUDA
 Requires the Metal toolchain. Install [Xcode](https://developer.apple.com/xcode/) first, then:
 ```shell
 xcodebuild -downloadComponent MetalToolchain
 ```
 Verify it's installed correctly (should print "no input files"):
 ```shell
 xcrun metal
 ```
 Then build:
 ```shell
 cmake -B build --preset MLX
 cmake --build build --preset MLX --parallel
 cmake --install build --component MLX
 ```
 > [!NOTE]
 > Without the Metal toolchain, cmake will silently complete with Metal disabled. Check the cmake output for `Setting MLX_BUILD_METAL=OFF` which indicates the toolchain is missing.
 ### Windows / Linux (CUDA)
 Requires CUDA 13+ and [cuDNN](https://developer.nvidia.com/cudnn) 9+.
 ```shell
-cmake -B build --preset "MLX CUDA 13"
+cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13
-cmake --build build --target mlx --target mlxc --config Release --parallel
+cmake --build build --parallel 8
 cmake --install build --component MLX --strip
 ```
 ### Local MLX source overrides
@@ -173,17 +139,20 @@ export OLLAMA_MLX_SOURCE=/path/to/mlx
 export OLLAMA_MLX_C_SOURCE=/path/to/mlx-c
 ```
-For example, using the helper scripts with local mlx and mlx-c repos:
+On macOS arm64:
 ```shell
 OLLAMA_MLX_SOURCE=../mlx OLLAMA_MLX_C_SOURCE=../mlx-c ./scripts/build_linux.sh
-OLLAMA_MLX_SOURCE=../mlx OLLAMA_MLX_C_SOURCE=../mlx-c ./scripts/build_darwin.sh
+```shell
 OLLAMA_MLX_SOURCE=../mlx OLLAMA_MLX_C_SOURCE=../mlx-c cmake -B build .
 cmake --build build --parallel 8
 ```
 For CUDA:
 ```powershell
 $env:OLLAMA_MLX_SOURCE="../mlx"
 $env:OLLAMA_MLX_C_SOURCE="../mlx-c"
-./scripts/build_darwin.ps1
+cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13
 cmake --build build --parallel 8
 ```
 ## Docker
@@ -208,11 +177,11 @@ go test ./...
 ## Library detection
-Ollama looks for acceleration libraries in the following paths relative to the `ollama` executable:
+Ollama looks for native helper binaries and acceleration libraries in installed and local development layouts:
-* `./lib/ollama` (Windows)
+* `../lib/ollama` for standard installs where `ollama` is under `bin/`
-* `../lib/ollama` (Linux)
+* `./lib/ollama` for Windows release-style payloads and local dist output
-* `.` (macOS)
+* `.` for macOS release artifacts that colocate helpers with `ollama`
-* `build/lib/ollama` (for development)
+* `build/lib/ollama` and `dist/<platform>/lib/ollama` for local development builds
 If the libraries are not found, Ollama will not run with any acceleration libraries.
@@ -70,12 +70,16 @@ docker run -d --device /dev/kfd --device /dev/dri -v ollama:/root/.ollama -p 114
 ## Vulkan Support
-Vulkan is bundled into the `ollama/ollama` image.  
+Vulkan is bundled into the `ollama/ollama` image and is enabled by default when
 the container can access the GPU devices.
 ```shell
-docker run -d --device /dev/kfd --device /dev/dri -v ollama:/root/.ollama -p 11434:11434 -e OLLAMA_VULKAN=1 --name ollama ollama/ollama
+docker run -d --device /dev/kfd --device /dev/dri -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
 ```
 Use `OLLAMA_VULKAN=0` to disable Vulkan, or `GGML_VK_VISIBLE_DEVICES=<ids>` to
 select specific Vulkan devices.
 ## Run model locally
@@ -88,4 +92,3 @@ docker exec -it ollama ollama run llama3.2
 ## Try different models
 More models can be found on the [Ollama library](https://ollama.com/library).
@@ -60,6 +60,26 @@
    }
  },
  "redirects": [
    {
      "source": "/development.md",
      "destination": "/development"
    },
    {
      "source": "/api/openai-compatibility.mdx",
      "destination": "/api/openai-compatibility"
    },
    {
      "source": "/gpu.mdx",
      "destination": "/gpu"
    },
    {
      "source": "/integrations/vscode.mdx",
      "destination": "/integrations/vscode"
    },
    {
      "source": "/troubleshooting.mdx",
      "destination": "/troubleshooting"
    },
    {
      "source": "/openai",
      "destination": "/api/openai-compatibility"
@@ -76,6 +96,14 @@
      "source": "/integrations/clawdbot",
      "destination": "/integrations/openclaw"
    },
    {
      "source": "/integrations/codex-app",
      "destination": "/integrations/chatgpt"
    },
    {
      "source": "/integrations/codex-app.mdx",
      "destination": "/integrations/chatgpt"
    },
    {
      "source": "/integrations/poolside",
      "destination": "/integrations/pool"
@@ -84,7 +112,7 @@
  "navigation": {
    "tabs": [
      {
-        "tab": "Documentation",
+        "tab": "Guide",
        "groups": [
          {
            "group": "Get started",
@@ -100,80 +128,17 @@
              "/capabilities/streaming",
              "/capabilities/thinking",
              "/capabilities/structured-outputs",
              "/capabilities/decision",
              "/capabilities/vision",
              "/capabilities/embeddings",
              "/capabilities/tool-calling",
              "/capabilities/web-search"
            ]
          },
          {
            "group": "Integrations",
            "pages": [
              "/integrations/index",
              {
                "group": "Assistants",
                "expanded": true,
                "pages": [
                  "/integrations/openclaw",
                  "/integrations/hermes"
                ]
              },
              {
                "group": "Coding",
                "expanded": true,
                "pages": [
                  "/integrations/claude-code",
                  "/integrations/codex",
                  "/integrations/copilot-cli",
                  "/integrations/opencode",
                  "/integrations/droid",
                  "/integrations/goose",
                  "/integrations/pi",
                  "/integrations/pool"
                ]
              },
              {
                "group": "IDEs & Editors",
                "expanded": true,
                "pages": [
                  "/integrations/cline",
                  "/integrations/jetbrains",
                  "/integrations/roo-code",
                  "/integrations/vscode",
                  "/integrations/xcode",
                  "/integrations/zed"
                ]
              },
              {
                "group": "Chat & RAG",
                "pages": [
                  "/integrations/onyx"
                ]
              },
              {
                "group": "Automation",
                "pages": [
                  "/integrations/n8n"
                ]
              },
              {
                "group": "Notebooks",
                "pages": [
                  "/integrations/marimo"
                ]
              }
            ]
          },
          {
            "group": "More information",
            "pages": [
              "/cli",
              {
                "group": "Assistant Sandboxing",
                "pages": [
                  "/integrations/nemoclaw"
                ]
              },
              "/modelfile",
              "/context-length",
              "/linux",
@@ -188,6 +153,81 @@
          }
        ]
      },
      {
        "tab": "Integrations",
        "groups": [
          {
            "group": "Integrations",
            "pages": [
              "/integrations/index"
            ]
          },
          {
            "group": "Assistants",
            "expanded": true,
            "pages": [
              "/integrations/claude-desktop",
              "/integrations/openclaw",
              "/integrations/hermes",
              "/integrations/hermes-desktop"
            ]
          },
          {
            "group": "Coding",
            "expanded": true,
            "pages": [
              "/integrations/claude-code",
              "/integrations/opencode",
              "/integrations/deepseek-harness",
              "/integrations/cline-cli",
              "/integrations/codex",
              "/integrations/chatgpt",
              "/integrations/copilot-cli",
              "/integrations/droid",
              "/integrations/goose",
              "/integrations/oh-my-pi",
              "/integrations/pi",
              "/integrations/pool"
            ]
          },
          {
            "group": "IDEs & Editors",
            "expanded": true,
            "pages": [
              "/integrations/vscode",
              "/integrations/cline",
              "/integrations/jetbrains",
              "/integrations/roo-code",
              "/integrations/xcode",
              "/integrations/zed"
            ]
          },
          {
            "group": "Chat & RAG",
            "pages": [
              "/integrations/onyx"
            ]
          },
          {
            "group": "Automation",
            "pages": [
              "/integrations/n8n"
            ]
          },
          {
            "group": "Notebooks",
            "pages": [
              "/integrations/marimo"
            ]
          },
          {
            "group": "Assistant Sandboxing",
            "pages": [
              "/integrations/nemoclaw"
            ]
          }
        ]
      },
      {
        "tab": "API Reference",
        "openapi": "/openapi.yaml",
@@ -210,6 +250,7 @@
              "POST /api/generate",
              "POST /api/chat",
              "POST /api/embed",
              "POST /v1/systemone",
              "GET /api/tags",
              "GET /api/ps",
              "POST /api/show",
@@ -218,7 +259,9 @@
              "POST /api/pull",
              "POST /api/push",
              "DELETE /api/delete",
-              "GET /api/version"
+              "GET /api/version",
              "/api/cloud-usage",
              "/api/balance"
            ]
          }
        ]
@@ -11,4 +11,4 @@ Ollama JavaScript examples at [ollama-js/examples](https://github.com/ollama/oll
 ## OpenAI compatibility examples
-Ollama OpenAI compatibility examples at [ollama/examples/openai](../docs/openai.md)
+Ollama OpenAI compatibility examples at [ollama/examples/openai](./api/openai-compatibility.mdx)
@@ -160,7 +160,7 @@ docker run -d -e HTTPS_PROXY=https://my.proxy.example.com -p 11434:11434 ollama-
 Ollama runs locally. We don't see your prompts or data when you run locally. When using cloud-hosted models, we process your prompts and responses to provide the service but do not store or log that content and never train on it. We collect basic account info and limited usage metadata to provide the service that does not include prompt or response content. We don't sell your data. You can delete your account anytime.
-## How do I disable Ollama's cloud features?
+## How do I disable Ollama Cloud features?
 Ollama can run in local only mode by disabling Ollama's cloud features. By turning off Ollama's cloud features, you will lose the ability to use Ollama's cloud models and web search. 
@@ -248,7 +248,7 @@ Refer to the section [above](#how-do-i-configure-ollama-server) for how to set e
 ## How can I use Ollama in Visual Studio Code?
-There is already a large collection of plugins available for VS Code as well as other editors that leverage Ollama. See the list of [extensions & plugins](https://github.com/ollama/ollama#extensions--plugins) at the bottom of the main repository readme.
+Install the [Ollama extension](https://marketplace.visualstudio.com/items?itemName=Ollama.ollama) to use Ollama models in VS Code Chat. See the [VS Code integration guide](./integrations/vscode.mdx) for setup and troubleshooting.
 ## How do I use Ollama with GPU acceleration in Docker?
@@ -343,7 +343,7 @@ When loading a new model, Ollama evaluates the required VRAM for the model again
 ## How can I enable Flash Attention?
-Flash Attention is a feature of most modern models that can significantly reduce memory usage as the context size grows. To enable Flash Attention, set the `OLLAMA_FLASH_ATTENTION` environment variable to `1` when starting the Ollama server.
+Flash Attention is a feature of most modern models that can significantly reduce memory usage as the context size grows. Ollama uses Flash Attention automatically when the selected backend and devices support it. To force Flash Attention on, set `OLLAMA_FLASH_ATTENTION=1` when starting the Ollama server. To disable it, set `OLLAMA_FLASH_ATTENTION=0`.
 ## How can I set the quantization type for the K/V cache?
@@ -3,7 +3,8 @@ title: Hardware support
 ---
 ## Nvidia
-Ollama supports Nvidia GPUs with compute capability 5.0+ and driver version 531 and newer.
+Ollama supports Nvidia GPUs with compute capability 5.0+ and driver version 550 and newer.
 Nvidia GPUs with compute capability 5.0 through 6.2 require driver version 570 or newer.
 Check your compute compatibility to see if your card is supported:
 [https://developer.nvidia.com/cuda-gpus](https://developer.nvidia.com/cuda-gpus)
@@ -34,7 +35,7 @@ Check your compute compatibility to see if your card is supported:
 | 5.0                | GeForce GTX         | `GTX 750 Ti` `GTX 750` `NVS 810`                                                                                               |
 |                    | Quadro              | `K2200` `K1200` `K620` `M1200` `M520` `M5000M` `M4000M` `M3000M` `M2000M` `M1000M` `K620M` `M600M` `M500M`                     |
-For building locally to support older GPUs, see [developer](./development#linux-cuda-nvidia)
+For building locally to support older GPUs, see [development](./development.md).
 ### GPU Selection
@@ -67,7 +68,7 @@ using the `amdgpu-install` utility from
 | Family         | Cards and accelerators                                                                                                                                         |
 | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| AMD Radeon RX  | `9070 XT` `9070 GRE` `9070` `9060 XT` `9060 XT LP` `9060` `7900 XTX` `7900 XT` `7900 GRE` `7800 XT` `7700 XT` `7700` `7600 XT` `7600` `6950 XT` `6900 XTX` `6900XT` `6800 XT` `6800` `5700 XT` `5700` `5600 XT` `5500 XT` |
+| AMD Radeon RX  | `9070 XT` `9070 GRE` `9070` `9060 XT` `9060 XT LP` `9060` `7900 XTX` `7900 XT` `7900 GRE` `7800 XT` `7700 XT` `7700` `7600 XT` `7600` `6950 XT` `6900 XTX` `6900XT` `6800 XT` `6800` |
 | AMD Radeon AI PRO | `R9700` `R9600D`                                                                                                                                            |
 | AMD Radeon PRO | `W7900` `W7800` `W7700` `W7600` `W7500` `W6900X` `W6800X Duo` `W6800X` `W6800` `V620`                                                                        |
 | AMD Ryzen AI   | `Ryzen AI Max+ 395` `Ryzen AI Max 390` `Ryzen AI Max 385` `Ryzen AI 9 HX 475` `Ryzen AI 9 HX 470` `Ryzen AI 9 465` `Ryzen AI 9 HX 375` `Ryzen AI 9 HX 370` `Ryzen AI 9 365` |
@@ -75,12 +76,12 @@ using the `amdgpu-install` utility from
 ### Windows Support
-With ROCm v6.1, the following GPUs are supported on Windows.
+Ollama requires an AMD ROCm v7 / HIP7-capable driver stack on Windows.
 | Family         | Cards and accelerators                                                                                               |
 | -------------- | -------------------------------------------------------------------------------------------------------------------- |
-| AMD Radeon RX  | `7900 XTX` `7900 XT` `7900 GRE` `7800 XT` `7700 XT` `7600 XT` `7600` `6950 XT` `6900 XTX` `6900XT` `6800 XT` `6800`  |
+| AMD Radeon RX  | `7900 XTX` `7900 XT` `7900 GRE` `7800 XT` `7700 XT` `7600 XT` `7600`  |
-| AMD Radeon PRO | `W7900` `W7800` `W7700` `W7600` `W7500` `W6900X` `W6800X Duo` `W6800X` `W6800` `V620`                                |
+| AMD Radeon PRO | `W7900` `W7800` `W7700` `W7600` `W7500`                                |
 ### Overrides on Linux
@@ -106,13 +107,10 @@ This table shows some example GPUs that map to these LLVM targets:
 | gfx90a | Radeon Instinct MI210/MI250 |
 | gfx942 | Radeon Instinct MI300X/MI300A |
 | gfx950 | Radeon Instinct MI350X |
 | gfx1010 | Radeon RX 5700 XT |
 | gfx1012 | Radeon RX 5500 XT |
 | gfx1030 | Radeon PRO V620 |
 | gfx1100 | Radeon PRO W7900 |
 | gfx1101 | Radeon PRO W7700 |
 | gfx1102 | Radeon RX 7600 |
 | gfx1103 | Radeon 780M |
 | gfx1150 | Ryzen AI 9 HX 375 |
 | gfx1151 | Ryzen AI Max+ 395 |
 | gfx1200 | Radeon RX 9070 |
@@ -142,12 +140,9 @@ Ollama supports GPU acceleration on Apple devices via the Metal API.
 ## Vulkan GPU Support
 > **NOTE:**
 > Vulkan is currently an Experimental feature.  To enable, you must set OLLAMA_VULKAN=1 for the Ollama server as
 described in the [FAQ](faq#how-do-i-configure-ollama-server)
 Additional GPU support on Windows and Linux is provided via
-[Vulkan](https://www.vulkan.org/). On Windows most GPU vendors drivers come
+[Vulkan](https://www.vulkan.org/). Vulkan is enabled by default when the
 backend is installed. On Windows most GPU vendors drivers come
 bundled with Vulkan support and require no additional setup steps. Most Linux
 distributions require installing additional components, and you may have
 multiple options for Vulkan drivers between Mesa and GPU Vendor specific packages
@@ -173,4 +168,9 @@ To select specific Vulkan GPU(s), you can set the environment variable
 `GGML_VK_VISIBLE_DEVICES` to one or more numeric IDs on the Ollama server as
 described in the [FAQ](faq#how-do-i-configure-ollama-server). If you
 encounter any problems with Vulkan based GPUs, you can disable all Vulkan GPUs
-by setting `GGML_VK_VISIBLE_DEVICES=-1` 
+by setting `OLLAMA_VULKAN=0` or `GGML_VK_VISIBLE_DEVICES=-1`.
 On mixed iGPU/dGPU systems where the Vulkan iGPU is unstable, keep Vulkan
 enabled and set `GGML_VK_VISIBLE_DEVICES` to the discrete GPU index. For
 example, use `GGML_VK_VISIBLE_DEVICES=1` when `Vulkan1` is the discrete
 GPU.
@@ -0,0 +1,4 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320">
  <style>@media (prefers-color-scheme: dark) { path { fill: #fff; } }</style>
  <path d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/>
 </svg>
@@ -0,0 +1 @@
 <svg height="24" style="flex:none;line-height:1" viewBox="-1 -1 26 26" width="24" xmlns="http://www.w3.org/2000/svg"><title>Claude Code</title><path clip-rule="evenodd" d="M20.998 10.949H24v3.102h-3v3.028h-1.487V20H18v-2.921h-1.487V20H15v-2.921H9V20H7.488v-2.921H6V20H4.487v-2.921H3V14.05H0V10.95h3V5h17.998v5.949zM6 10.949h1.488V8.102H6v2.847zm10.51 0H18V8.102h-1.49v2.847z" fill="#D97757" fill-rule="evenodd"></path></svg>
@@ -0,0 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- Generated by Pixelmator Pro 3.6.17 -->
 <svg width="1200" height="1200" viewBox="0 0 1200 1200" xmlns="http://www.w3.org/2000/svg">
    <g id="g314">
        <path id="path147" fill="#d97757" stroke="none" d="M 233.959793 800.214905 L 468.644287 668.536987 L 472.590637 657.100647 L 468.644287 650.738403 L 457.208069 650.738403 L 417.986633 648.322144 L 283.892639 644.69812 L 167.597321 639.865845 L 54.926208 633.825623 L 26.577238 627.785339 L 3.3e-05 592.751709 L 2.73832 575.27533 L 26.577238 559.248352 L 60.724873 562.228149 L 136.187973 567.382629 L 249.422867 575.194763 L 331.570496 580.026978 L 453.261841 592.671082 L 472.590637 592.671082 L 475.328857 584.859009 L 468.724915 580.026978 L 463.570557 575.194763 L 346.389313 495.785217 L 219.543671 411.865906 L 153.100723 363.543762 L 117.181267 339.060425 L 99.060455 316.107361 L 91.248367 266.01355 L 123.865784 230.093994 L 167.677887 233.073853 L 178.872513 236.053772 L 223.248367 270.201477 L 318.040283 343.570496 L 441.825592 434.738342 L 459.946411 449.798706 L 467.194672 444.64447 L 468.080597 441.020203 L 459.946411 427.409485 L 392.617493 305.718323 L 320.778564 181.932983 L 288.80542 130.630859 L 280.348999 99.865845 C 277.369171 87.221436 275.194641 76.590698 275.194641 63.624268 L 312.322174 13.20813 L 332.8591 6.604126 L 382.389313 13.20813 L 403.248352 31.328979 L 434.013519 101.71814 L 483.865753 212.537048 L 561.181274 363.221497 L 583.812134 407.919434 L 595.892639 449.315491 L 600.40271 461.959839 L 608.214783 461.959839 L 608.214783 454.711609 L 614.577271 369.825623 L 626.335632 265.61084 L 637.771851 131.516846 L 641.718201 93.745117 L 660.402832 48.483276 L 697.530334 24.000122 L 726.52356 37.852417 L 750.362549 72 L 747.060486 94.067139 L 732.886047 186.201416 L 705.100708 330.52356 L 686.979919 427.167847 L 697.530334 427.167847 L 709.61084 415.087341 L 758.496704 350.174561 L 840.644348 247.490051 L 876.885925 206.738342 L 919.167847 161.71814 L 946.308838 140.29541 L 997.61084 140.29541 L 1035.38269 196.429626 L 1018.469849 254.416199 L 965.637634 321.422852 L 921.825562 378.201538 L 859.006714 462.765259 L 819.785278 530.41626 L 823.409424 535.812073 L 832.75177 534.92627 L 974.657776 504.724915 L 1051.328979 490.872559 L 1142.818848 475.167786 L 1184.214844 494.496582 L 1188.724854 514.147644 L 1172.456421 554.335693 L 1074.604126 578.496765 L 959.838989 601.449829 L 788.939636 641.879272 L 786.845764 643.409485 L 789.261841 646.389343 L 866.255127 653.637634 L 899.194702 655.409424 L 979.812134 655.409424 L 1129.932861 666.604187 L 1169.154419 692.537109 L 1192.671265 724.268677 L 1188.724854 748.429688 L 1128.322144 779.194641 L 1046.818848 759.865845 L 856.590759 714.604126 L 791.355774 698.335754 L 782.335693 698.335754 L 782.335693 703.731567 L 836.69812 756.885986 L 936.322205 846.845581 L 1061.073975 962.81897 L 1067.436279 991.490112 L 1051.409424 1014.120911 L 1034.496704 1011.704712 L 924.885986 929.234924 L 882.604126 892.107544 L 786.845764 811.48999 L 780.483276 811.48999 L 780.483276 819.946289 L 802.550415 852.241699 L 919.087341 1027.409424 L 925.127625 1081.127686 L 916.671204 1098.604126 L 886.469849 1109.154419 L 853.288696 1103.114136 L 785.073914 1007.355835 L 714.684631 899.516785 L 657.906067 802.872498 L 650.979858 806.81897 L 617.476624 1167.704834 L 601.771851 1186.147705 L 565.530212 1200 L 535.328857 1177.046997 L 519.302124 1139.919556 L 535.328857 1066.550537 L 554.657776 970.792053 L 570.362488 894.68457 L 584.536926 800.134277 L 592.993347 768.724976 L 592.429626 766.630859 L 585.503479 767.516968 L 514.22821 865.369263 L 405.825531 1011.865906 L 320.053711 1103.677979 L 299.516815 1111.812256 L 263.919525 1093.369263 L 267.221497 1060.429688 L 287.114136 1031.114136 L 405.825531 880.107361 L 477.422913 786.52356 L 523.651062 732.483276 L 523.328918 724.671265 L 520.590698 724.671265 L 205.288605 929.395935 L 149.154434 936.644409 L 124.993355 914.01355 L 127.973183 876.885986 L 139.409409 864.80542 L 234.201385 799.570435 L 233.879227 799.8927 Z"/>
    </g>
 </svg>
@@ -0,0 +1,4 @@
 <svg xmlns="http://www.w3.org/2000/svg" width="50" height="50" viewBox="0 0 50 50" fill="none">
  <style>@media (prefers-color-scheme: dark) { path { fill: #fff; } }</style>
  <path d="M48.8354 10.0479C48.3232 9.79199 48.1025 10.2798 47.8032 10.5278C46.7793 11.624 45.9048 12.1597 44.7622 12.0957C43.0923 12 41.666 12.5356 40.4058 13.8398C40.1377 12.2319 39.2476 11.272 37.8926 10.6558C36.4668 10.0156 35.9702 9.31982 35.356 7.72754C35.2456 7.3999 35.1353 7.06396 34.7651 7.00781C34.3633 6.94385 34.2056 7.2876 34.0479 7.57568C33.418 8.75195 33.1733 10.0479 33.1973 11.3599C33.2524 14.312 34.4736 16.6641 36.8999 18.3359C37.1758 18.5278 37.2466 18.7197 37.1597 19C36.9946 19.5757 36.7974 20.1357 36.624 20.7119C36.5137 21.0801 36.3486 21.1597 35.9624 21C32.4092 19.4878 30.0381 16.2319 27.2334 13.52C26.7764 13.1758 26.3193 12.856 25.8467 12.5518C23.8618 10.584 26.1069 8.96777 26.627 8.77588C27.1704 8.57568 26.8159 7.8877 25.0591 7.896C22.8691 7.90381 20.4507 9.06396 18.7095 9.58398C16.8501 9.22363 14.9199 9.14355 12.9033 9.37598C5.30859 10.2397 1.15674 16.4717 1.30664 27.2559C2.11768 31.9521 4.46582 35.8398 8.07373 38.8799C11.8159 42.0322 16.1255 43.5762 21.041 43.2803C24.0269 43.104 27.3516 42.6963 31.1016 39.4561C33.0396 40.1279 37.1758 40.208 38.1211 40.0078C39.6021 39.688 39.4995 38.2881 38.9639 38.0322C34.623 35.9678 35.5762 36.8081 34.71 36.1279C36.9155 33.4639 40.2402 30.6958 41.54 21.728C41.6426 21.0161 41.5557 20.5679 41.54 19.9917C41.5322 19.6396 41.6108 19.5039 42.0049 19.4639C46.6924 18.9116 49.064 15.9038 49.3315 11.2559C49.3711 10.7837 49.3237 10.2959 48.8354 10.0479ZM24.3262 37.8398C20.1196 34.4639 18.0791 33.3521 17.2358 33.3999C16.4482 33.4482 16.5898 34.3682 16.7632 34.9678C16.9443 35.5601 17.1812 35.9683 17.5117 36.4878C17.7402 36.832 17.8979 37.3442 17.2832 37.728C15.9282 38.584 13.5728 37.4399 13.4624 37.3838C7.97949 34.0879 4.48926 28.9282 4.19775 21.3677C4.1582 20.5757 4.38672 20.2959 5.15869 20.1519C11.8945 18.8799 17.165 22.0879 19.2529 25.7759C23.5381 30.104 25.335 35.1523 30.479 39.104C28.8643 39.2881 26.1699 39.3281 24.3262 37.8398ZM26.3433 24.6001C26.3433 24.248 26.6191 23.9678 26.9658 23.9678C27.3042 23.9678 27.5801 24.248 27.5801 24.6001C27.5801 24.9521 27.3042 25.2319 26.9575 25.2319C26.6108 25.2319 26.3433 24.9521 26.3433 24.6001ZM32.6064 27.8799C31.6372 28.2881 30.6289 28.3042 29.8096 27.688C28.6987 26.8555 28.6279 25.7759 28.7305 24.9199C28.8721 24.248 28.7144 23.8159 28.2495 23.4238C27.8716 23.104 27.3911 23.0161 26.8633 23.0161C26.666 23.0161 26.4849 22.9277 26.3511 22.856C25.8467 22.5762 25.9805 22.1758 26.5088 21.688C28.0996 20.7598 29.6362 21.9917 30.834 23.3281C31.6216 24.2559 32.8901 26.312 33.1104 26.9521C33.2446 27.3521 33.0713 27.6802 32.6064 27.8799Z" fill="#000"/>
 </svg>
@@ -0,0 +1,181 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" width="1000" height="1000" viewBox="-25 -25 1050 1050"><circle cx="500.0" cy="500.0" r="500.0" fill="white"/><g transform="translate(50.0 50.0) scale(0.9375)"><g transform="translate(0.000000,960.000000) scale(0.100000,-0.100000)"
 fill="black" stroke="none">
 <path d="M4485 9589 c-248 -27 -432 -60 -730 -130 -458 -108 -798 -230 -1207
 -435 -533 -267 -1072 -675 -1358 -1030 -205 -255 -442 -748 -535 -1114 -108
 -426 -97 -870 29 -1160 73 -169 236 -369 381 -467 139 -94 425 -206 425 -167
 0 3 -26 32 -58 63 -74 71 -147 182 -184 278 -16 41 -27 77 -25 79 2 3 31 -28
 63 -68 91 -114 153 -177 231 -235 40 -29 77 -62 83 -73 7 -13 4 -85 -10 -242
 -10 -123 -24 -281 -30 -353 -6 -71 -29 -296 -51 -500 -135 -1262 -202 -1568
 -378 -1733 -69 -64 -105 -77 -216 -77 -132 0 -188 20 -271 97 -110 103 -165
 248 -167 438 -1 123 12 191 60 318 20 51 33 95 29 99 -10 10 -92 -74 -136
 -137 -153 -223 -204 -504 -146 -790 19 -91 97 -252 161 -333 112 -141 316
 -237 504 -237 180 0 419 118 591 290 81 81 107 115 196 255 50 78 54 56 13
 -71 -107 -337 -343 -577 -613 -625 -213 -39 -544 99 -707 295 -93 111 -133
 199 -173 381 -34 153 -34 154 -46 135 -15 -23 -12 -194 5 -305 42 -280 149
 -488 327 -636 133 -111 287 -195 465 -254 62 -20 115 -40 117 -44 3 -4 12 -43
 21 -87 44 -222 199 -385 416 -438 96 -24 265 -21 359 5 138 38 281 148 388
 297 39 55 48 63 50 45 4 -27 -38 -185 -78 -294 -80 -217 -176 -374 -312 -515
 -54 -55 -98 -104 -98 -107 0 -4 245 -7 545 -7 l544 0 126 66 c69 36 130 64
 135 62 6 -2 -10 -28 -34 -59 -46 -59 -48 -69 -10 -69 17 0 32 15 58 59 36 59
 51 71 87 71 23 0 25 -27 4 -77 -8 -19 -15 -39 -15 -44 0 -12 447 -11 470 1 10
 5 85 87 168 182 257 297 400 415 317 263 -16 -30 -26 -57 -23 -60 11 -12 210
 100 383 215 115 76 226 143 375 225 58 32 178 100 266 151 150 87 244 132 244
 117 0 -4 -78 -86 -174 -182 -207 -208 -246 -254 -334 -386 -48 -71 -122 -157
 -259 -298 -117 -120 -193 -206 -193 -217 0 -19 8 -20 115 -20 101 0 116 2 122
 18 19 54 112 249 156 327 124 221 283 436 369 502 87 67 225 152 337 209 103
 51 297 117 384 130 38 6 29 -2 -92 -75 -74 -45 -170 -107 -214 -139 -106 -76
 -247 -225 -332 -351 -67 -99 -70 -102 -79 -77 -6 14 -13 26 -18 26 -11 0 -57
 -75 -94 -155 -63 -136 -124 -376 -103 -401 15 -18 152 -19 166 -2 6 7 18 36
 27 63 23 72 66 131 217 301 302 339 430 464 590 577 148 104 233 128 520 148
 205 14 255 9 447 -38 118 -29 183 -65 298 -163 229 -195 538 -577 579 -715 24
 -83 71 -117 109 -79 9 8 16 27 16 42 0 62 -40 212 -73 277 -158 313 -551 635
 -922 755 -127 41 -142 55 -52 46 117 -11 231 -35 321 -65 158 -54 259 -123
 405 -277 164 -174 283 -379 322 -556 11 -51 25 -113 32 -137 36 -128 148 -81
 117 49 -14 60 -7 106 27 177 36 74 62 94 224 179 254 133 425 260 561 417 272
 315 403 732 358 1138 -24 218 -84 401 -179 545 -65 98 -155 203 -166 192 -3
 -3 7 -37 23 -75 136 -309 136 -725 2 -1063 -130 -330 -441 -760 -633 -879 -60
 -37 -60 -20 2 54 478 577 578 1337 315 2390 -25 99 -86 326 -136 505 -169 611
 -386 1539 -494 2109 -161 857 -200 998 -442 1606 -161 405 -321 692 -529 950
 -93 114 -322 343 -433 431 -203 160 -497 332 -737 428 -293 118 -702 220 -978
 246 -129 12 -406 11 -520 -1z m-267 -214 c301 -47 596 -191 852 -419 85 -76
 266 -270 345 -371 294 -376 520 -873 640 -1409 45 -199 45 -222 3 -244 -18 -9
 -45 -30 -61 -45 -25 -23 -28 -33 -23 -60 9 -44 21 -54 121 -98 91 -40 225
 -124 225 -140 0 -9 -33 5 -211 89 -126 60 -159 94 -167 173 -5 50 14 89 43 89
 26 0 65 49 65 81 0 52 -22 110 -48 127 -23 15 -37 14 -186 -7 -172 -25 -210
 -36 -240 -69 -23 -27 -31 -99 -14 -131 16 -29 30 -37 85 -51 26 -7 44 -17 48
 -29 10 -32 -15 -153 -41 -197 -27 -49 -131 -161 -139 -152 -9 9 36 77 85 126
 23 24 48 60 56 79 13 31 13 38 -3 71 -10 20 -29 42 -43 48 -14 7 -37 18 -52
 24 -33 15 -42 39 -63 155 -24 133 -90 393 -135 532 -119 367 -287 686 -483
 919 -175 208 -434 427 -659 557 -229 131 -498 197 -804 197 -136 0 -185 -4
 -313 -26 -87 -14 -31 14 137 70 186 61 289 89 437 117 120 23 376 20 543 -6z
 m2913 -962 c50 -53 113 -138 198 -268 76 -116 60 -104 -41 32 -34 46 -63 81
 -66 79 -2 -2 2 -30 9 -63 9 -44 9 -86 1 -171 -6 -63 -13 -116 -16 -119 -3 -4
 -15 2 -26 12 -32 29 -34 12 -5 -57 50 -118 66 -160 62 -164 -2 -2 -29 34 -61
 81 -31 47 -61 83 -66 80 -6 -4 -7 -24 -4 -47 7 -39 6 -40 -14 -27 -12 7 -25
 10 -29 5 -17 -17 -4 -106 31 -210 20 -60 35 -111 33 -112 -2 -2 -30 43 -62 99
 -60 102 -173 233 -182 210 -2 -7 26 -82 62 -168 37 -85 65 -160 63 -166 -2 -6
 -43 66 -91 160 -63 121 -93 171 -106 171 -9 0 -37 -21 -61 -46 -55 -56 -56
 -56 -248 20 -78 31 -156 59 -172 63 l-30 6 24 -54 c13 -30 51 -114 85 -188 34
 -73 60 -135 58 -137 -2 -3 -21 24 -42 58 -56 91 -85 128 -102 128 -13 0 -14
 -8 -9 -42 l7 -42 -83 80 c-109 106 -163 133 -260 126 -35 -3 -38 0 -53 34 -9
 21 -13 44 -11 51 7 17 58 16 147 -2 101 -21 104 -17 92 106 -6 52 -7 98 -3
 102 4 5 25 -20 47 -55 22 -35 47 -68 54 -75 18 -14 278 -83 316 -83 23 0 42
 13 86 59 61 64 64 72 42 111 -19 33 -19 54 0 46 11 -4 23 6 37 30 l21 35 66
 -3 66 -3 -2 29 c-1 16 -25 63 -52 105 -28 41 -49 77 -47 78 2 2 47 -42 101
 -97 75 -76 105 -100 125 -100 14 0 35 -7 47 -15 20 -14 22 -14 27 2 3 10 6 72
 7 138 2 102 -1 128 -19 175 -12 30 -22 56 -22 58 0 9 40 -22 71 -55z m-2642
 -139 c29 -35 60 -64 67 -64 8 0 52 27 97 61 l82 60 47 -51 c59 -63 161 -218
 218 -327 23 -46 48 -83 55 -83 8 0 26 5 41 11 49 18 73 4 104 -64 33 -70 48
 -127 33 -127 -6 0 -32 9 -58 21 -28 12 -56 18 -71 15 -21 -6 -27 1 -55 56 -67
 132 -208 340 -244 361 -10 5 -19 -1 -29 -22 -29 -55 -35 -106 -20 -183 8 -40
 14 -74 14 -75 0 -1 -12 2 -26 8 l-27 10 7 -62 c6 -61 6 -62 -14 -44 -15 14
 -31 17 -72 13 -58 -6 -88 -32 -88 -76 l0 -26 -29 34 c-29 35 -30 35 -122 38
 -52 2 -99 8 -106 14 -15 12 -83 132 -83 146 0 6 23 39 50 73 56 70 68 99 52
 134 -12 27 -15 25 81 46 65 14 68 21 42 105 -26 85 -18 85 54 -2z m-397 -294
 c84 -126 196 -352 237 -475 33 -99 28 -115 -23 -66 -45 44 -55 29 -49 -77 5
 -95 -4 -97 -33 -7 -22 67 -52 125 -64 125 -6 0 -10 -39 -11 -92 0 -51 -4 -101
 -8 -111 -9 -23 -10 -22 -85 101 -32 50 -62 92 -68 92 -7 0 -9 -22 -4 -70 6
 -74 -3 -90 -24 -40 -21 50 -33 54 -87 30 -26 -11 -57 -30 -69 -41 -20 -19 -21
 -19 -75 10 -30 17 -91 41 -137 54 -46 13 -89 30 -97 38 -16 16 -45 142 -36
 157 3 5 58 33 121 61 l114 51 21 -26 21 -26 49 39 c51 40 69 66 80 116 5 23
 10 28 32 25 19 -2 28 -11 37 -38 37 -115 42 114 6 250 -45 171 -47 164 22 90
 33 -36 92 -112 130 -170z m-1789 73 c-3 -10 -32 -77 -63 -148 -48 -109 -137
 -340 -242 -628 -11 -32 -22 -56 -24 -54 -2 2 -9 32 -14 68 -24 141 -20 131
 -47 124 -13 -3 -50 -18 -81 -33 -43 -20 -62 -37 -79 -67 -32 -59 -40 -65 -88
 -65 -55 0 -56 6 -16 106 29 75 176 339 194 351 12 7 14 14 -47 -125 -25 -56
 -46 -113 -46 -127 0 -25 0 -25 35 -11 109 46 179 120 301 316 135 217 241 360
 217 293z m-869 -35 c-4 -7 -33 -49 -64 -93 -140 -200 -268 -431 -368 -665
 -114 -268 -153 -314 -74 -86 41 115 44 129 29 137 -28 16 -39 80 -22 128 27
 77 98 202 139 246 58 61 355 345 362 345 3 0 2 -6 -2 -12z m1415 -533 l1 -130
 -23 39 c-26 47 -41 51 -45 14 -4 -36 -18 -35 -37 1 -8 17 -19 32 -25 36 -5 3
 -60 -10 -122 -30 -76 -25 -130 -36 -165 -36 -29 1 -82 -5 -118 -14 -99 -23
 -109 -21 -149 29 -20 23 -36 50 -36 58 0 12 55 182 75 231 11 27 38 21 147
 -34 76 -38 108 -49 130 -45 21 4 28 2 28 -9 0 -10 11 -15 34 -15 45 0 153 34
 177 56 10 9 35 69 55 133 56 180 58 180 65 1 4 -85 7 -213 8 -285z m-1394 272
 c-31 -55 -32 -83 -2 -91 47 -12 65 -6 97 34 18 23 34 39 36 38 2 -2 -20 -48
 -48 -102 l-50 -99 33 7 c84 17 149 19 149 5 0 -8 -37 -104 -82 -213 -74 -177
 -83 -195 -86 -162 -4 50 -26 56 -66 17 -17 -17 -35 -31 -39 -31 -4 0 -7 18 -7
 40 0 28 -6 43 -18 51 -15 10 -18 21 -14 65 8 93 -18 69 -89 -80 -35 -74 -65
 -133 -67 -131 -3 2 5 35 17 74 11 38 21 74 21 80 0 6 -35 11 -87 13 l-88 3 3
 30 c4 42 162 364 187 381 11 8 44 14 76 14 55 0 59 2 93 42 20 23 36 45 36 50
 0 4 5 8 10 8 6 0 -1 -20 -15 -43z m1710 6 c120 -17 143 -19 164 -12 10 3 21
 -17 37 -67 24 -77 75 -306 69 -312 -2 -2 -21 14 -43 37 l-39 41 -145 0 c-128
 0 -148 2 -170 19 -16 13 -29 17 -39 10 -8 -5 -17 -9 -20 -9 -10 0 -66 178 -74
 232 -4 25 -4 56 0 68 7 21 11 22 79 16 39 -4 121 -14 181 -23z m-79 -988 c74
 -190 129 -303 247 -514 76 -136 79 -145 62 -157 -24 -17 -76 -18 -98 -1 -21
 16 -126 237 -165 347 -30 87 -143 516 -141 541 1 19 17 -19 95 -216z m3644 61
 c64 -163 185 -534 301 -926 66 -223 147 -490 179 -595 175 -566 250 -858 321
 -1240 22 -121 43 -231 46 -245 4 -18 3 -22 -6 -15 -6 6 -22 71 -36 145 -58
 313 -100 487 -200 820 -40 135 -94 317 -120 405 -161 550 -413 1387 -465 1540
 -55 165 -67 205 -56 194 2 -2 18 -39 36 -83z m-4395 -812 c61 -60 129 -118
 149 -128 46 -22 69 -19 238 25 70 18 130 30 133 27 3 -3 -19 -42 -49 -87 -53
 -78 -75 -125 -63 -137 14 -14 111 32 205 96 57 38 136 85 176 104 84 40 299
 116 327 116 12 0 37 -24 66 -65 25 -36 54 -67 62 -69 9 -2 178 -1 376 2 l360
 7 10 70 c10 68 10 69 22 40 7 -16 17 -49 23 -73 14 -53 18 -55 187 -82 178
 -28 191 -33 200 -78 12 -57 8 -612 -6 -742 -17 -170 -53 -395 -141 -880 -206
 -1142 -248 -1540 -194 -1863 8 -49 12 -97 9 -107 -8 -24 -195 -200 -213 -200
 -7 0 -21 14 -30 31 -140 256 -353 528 -467 594 -66 39 -95 39 -361 1 -137 -19
 -303 -40 -368 -47 -128 -12 -307 -7 -368 11 -54 16 -140 78 -185 132 -41 51
 -348 610 -438 801 -105 220 -178 478 -191 667 -7 97 11 328 25 343 5 5 23 -17
 41 -49 18 -32 72 -97 125 -148 54 -53 97 -104 101 -120 12 -50 -1 -119 -34
 -170 -22 -33 -32 -62 -32 -88 0 -45 31 -126 70 -182 23 -35 28 -50 23 -82 -3
 -24 4 -70 17 -119 18 -68 28 -87 68 -128 59 -60 118 -101 132 -92 6 4 10 18 8
 32 -3 22 3 28 48 44 28 11 59 28 70 40 l18 20 -107 -7 c-118 -8 -146 0 -166
 43 -17 37 -14 52 18 84 33 33 78 41 66 12 -14 -31 -16 -77 -5 -93 9 -13 14
 -11 36 14 21 24 25 37 21 68 -5 37 -4 38 36 49 56 15 192 6 242 -15 l40 -17
 -27 -20 c-66 -49 -1 -50 120 -2 80 31 92 40 92 64 0 33 -30 52 -72 45 -33 -5
 -51 1 -140 49 -226 121 -267 139 -327 139 -31 1 -68 -3 -83 -8 -24 -7 -32 -3
 -62 30 -62 67 -63 76 -30 145 53 111 38 151 -110 308 -88 93 -131 162 -142
 230 -11 67 0 84 99 164 142 113 222 232 261 384 46 178 -18 329 -188 441 -74
 48 -75 49 -51 60 35 16 31 28 -20 64 -31 22 -41 34 -32 40 21 14 168 59 252
 77 67 15 80 21 83 39 2 12 -33 92 -82 187 -100 193 -117 263 -35 144 28 -41
 102 -124 164 -185z m-430 -364 c-13 -21 19 -51 100 -97 78 -43 142 -93 119
 -93 -5 0 -34 7 -64 15 -69 19 -148 19 -180 0 -24 -14 -24 -14 21 -15 63 0 238
 -37 267 -56 24 -16 42 -52 42 -85 0 -17 -8 -14 -57 24 -92 71 -138 91 -213 90
 -36 0 -85 -8 -109 -17 -55 -20 -64 -14 -103 71 -37 82 -36 104 4 127 60 36
 190 63 173 36z m4328 -154 c76 -37 148 -103 127 -116 -27 -17 -107 -10 -174
 15 -91 34 -212 35 -310 1 -55 -19 -76 -22 -100 -14 -17 5 -37 12 -45 14 -17 6
 18 45 66 75 76 47 131 59 258 57 109 -3 125 -6 178 -32z m-4293 -282 c3 -28
 11 -58 17 -66 7 -8 12 -30 12 -49 -1 -40 10 -72 46 -128 33 -53 32 -67 -5 -80
 -78 -27 -118 37 -133 210 -10 105 -9 120 7 144 27 42 50 29 56 -31z m-53 -438
 c-4 -9 -11 -16 -17 -16 -11 0 -14 33 -3 44 11 10 26 -11 20 -28z m449 -922
 c60 -20 62 -23 44 -34 -23 -15 -104 -12 -126 5 -19 15 -19 15 0 30 24 18 22
 19 82 -1z m5843 -211 c82 -179 180 -472 218 -653 34 -160 38 -387 10 -517 -37
 -172 -107 -345 -191 -471 -81 -122 -215 -266 -232 -249 -2 2 10 37 27 78 188
 447 261 1077 185 1584 -15 98 -31 196 -35 217 -10 44 0 50 18 11z m-2689 -313
 c25 -333 24 -319 22 -342 -1 -10 -66 -56 -164 -115 -175 -106 -203 -121 -196
 -101 3 7 26 81 53 163 39 124 214 633 241 699 15 37 22 -12 44 -304z m110
 -832 c37 -172 37 -173 -56 -257 -80 -73 -143 -103 -230 -109 -105 -7 -132 9
 -183 108 -53 101 -53 132 -3 177 21 19 126 88 233 153 182 111 194 117 201 97
 3 -12 20 -88 38 -169z m-1046 -650 c67 -151 141 -236 331 -383 138 -106 239
 -173 309 -204 42 -18 47 -23 36 -36 -7 -9 -110 -81 -229 -160 -178 -118 -251
 -161 -416 -238 -110 -51 -250 -117 -312 -147 -62 -29 -118 -50 -126 -47 -7 3
 -24 34 -36 69 -28 77 -74 158 -252 445 -75 122 -140 231 -144 242 -6 19 -2 21
 42 21 63 0 171 24 230 50 35 15 99 72 238 209 182 180 271 261 285 261 4 0 24
 -37 44 -82z m-2387 -88 c-10 -81 -64 -284 -102 -378 -55 -136 -119 -238 -204
 -323 -108 -107 -162 -132 -306 -137 -109 -4 -111 -3 -175 30 -42 22 -76 48
 -98 78 l-35 45 114 7 c338 22 478 105 645 383 29 50 70 131 89 180 49 124 67
 165 73 165 3 0 2 -22 -1 -50z m1647 -1402 c-54 -78 -300 -358 -315 -358 -16 0
 -10 15 29 76 113 173 323 408 330 370 2 -10 -18 -49 -44 -88z"/>
 <path d="M3229 5845 c-108 -15 -150 -30 -198 -71 -49 -41 -111 -123 -111 -146
 0 -18 5 -20 40 -15 22 3 40 3 40 1 0 -2 -9 -26 -20 -53 -12 -32 -16 -52 -9
 -56 9 -6 7 -23 -8 -62 -3 -8 4 -13 20 -13 16 0 26 -7 30 -20 8 -30 33 -24 48
 12 15 37 122 148 142 148 12 0 11 -10 0 -56 -17 -66 -10 -118 17 -137 15 -11
 19 -21 14 -44 -5 -25 2 -39 44 -90 28 -33 66 -67 85 -76 39 -19 112 -22 152
 -7 39 15 108 74 140 121 27 38 28 41 13 72 -15 32 -15 34 8 54 13 12 24 33 24
 47 l0 25 38 -17 c58 -26 111 -62 122 -81 6 -13 3 -29 -11 -57 -98 -186 -404
 -264 -685 -174 -101 32 -143 37 -162 18 -21 -21 -13 -28 31 -28 49 0 82 -19
 91 -53 5 -20 11 -23 31 -19 14 2 31 0 38 -6 17 -14 145 -34 168 -27 11 4 26 1
 34 -5 9 -7 23 -9 37 -4 13 5 41 9 63 11 22 1 51 3 65 4 14 1 37 -1 52 -5 21
 -6 27 -4 33 13 5 18 14 21 55 21 43 0 49 3 52 23 3 19 10 22 51 25 49 3 53 7
 37 32 -11 17 4 30 38 30 15 0 22 6 22 19 0 14 16 27 55 45 40 18 56 31 61 51
 3 14 16 32 27 40 18 13 20 18 10 34 -11 17 -8 21 25 35 100 44 116 63 55 68
 -33 3 -38 6 -36 26 3 22 0 22 -45 16 -44 -6 -49 -4 -83 29 -58 56 -354 199
 -469 227 -116 28 -147 43 -70 36 30 -3 108 -23 173 -45 64 -22 117 -36 117
 -31 0 13 -23 24 -160 75 -142 53 -197 60 -331 40z"/>
 <path d="M3027 5303 c-3 -5 -2 -15 2 -22 7 -10 10 -10 16 -1 4 6 3 16 -3 22
 -5 5 -12 6 -15 1z"/>
 <path d="M2180 4462 c0 -11 136 -122 149 -122 19 0 12 46 -11 75 -12 15 -36
 34 -54 41 -37 15 -84 19 -84 6z"/>
 </g></g></svg>
@@ -0,0 +1,242 @@
 <svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 500 500" width="500" height="500">
 	<style>
 		.s0 { fill: #f6f4f4 } 
 		.s1 { fill: #0b0303 } 
 		.s2 { fill: #ef0011 } 
 		.s3 { fill: #f3e2e2 } 
 		.s4 { fill: #f00212 } 
 		.s5 { fill: #ba000d } 
 		.s6 { fill: #faf1f1 } 
 		.s7 { fill: #0b0100 } 
 		.s8 { fill: #fbedee } 
 		.s9 { fill: #faeaea } 
 		.s10 { fill: #ab797d } 
 		.s11 { fill: #f8eaea } 
 		.s12 { fill: #902021 } 
 		.s13 { fill: #f9eeee } 
 		.s14 { fill: #f6ecec } 
 		.s15 { fill: #080201 } 
 		.s16 { fill: #150100 } 
 		.s17 { fill: #f2e7e7 } 
 		.s18 { fill: #fbe7e8 } 
 		.s19 { fill: #060101 } 
 		.s20 { fill: #f5e7e7 } 
 		.s21 { fill: #fa999e } 
 		.s22 { fill: #c46064 } 
 		.s23 { fill: #180300 } 
 		.s24 { fill: #f6dcdd } 
 		.s25 { fill: #f2e6e6 } 
 		.s26 { fill: #110200 } 
 		.s27 { fill: #eb0011 } 
 		.s28 { fill: #e20010 } 
 		.s29 { fill: #ea0011 } 
 		.s30 { fill: #760007 } 
 		.s31 { fill: #f00514 } 
 		.s32 { fill: #fcebeb } 
 		.s33 { fill: #ecd6d6 } 
 		.s34 { fill: #f5e3e3 } 
 		.s35 { fill: #f5e4e4 } 
 		.s36 { fill: #faf6f6 } 
 		.s37 { fill: #e50010 } 
 		.s38 { fill: #d5000f } 
 		.s39 { fill: #f2e2e3 } 
 		.s40 { fill: #ef1018 } 
 		.s41 { fill: #f4e8e9 } 
 		.s42 { fill: #ef0513 } 
 		.s43 { fill: #f5e5e5 } 
 		.s44 { fill: #f00413 } 
 		.s45 { fill: #f4e9ea } 
 		.s46 { fill: #ed0011 } 
 		.s47 { fill: #e80011 } 
 		.s48 { fill: #e60613 } 
 		.s49 { fill: #f0d6d6 } 
 		.s50 { fill: #fca9ac } 
 		.s51 { fill: #9c000c } 
 		.s52 { fill: #73393b } 
 	</style>
 	<g>
 		<path fill-rule="evenodd" class="s0" d="m166.5 52.5q3.5 0 7 0 2.75 2.99 1.5 7-21.27 45.61-20.5 96 39.99 2.76 72 26.5 7.87 6.86 13.5 15.5 42.88-56.39 103.5-92.5 47.35-25.46 101-25 14.52 0.38 23.5 11.5 3.19 7.74 2 16-1.81 7.18-4.5 14-1 0-1 1-5.04 6.05-9 13-1 0-1 1 0 0.5 0 1-12.42 12.15-28.5 19-6.02 36.27-41.5 45-0.83 2.75 0 5 19.02-12.85 41.5-9 10.85-8.09 23.5-13 15.01-6.37 31-2.5 14.09 7.43 14 23.5-2.83 23.25-15.5 43-6.42 9.92-14 19-10.04 8.8-19.5 18-72.02 48.88-156.5 27-19.63 9.6-41.5 10.5-4.59 1.27-9 3 2 1 4 2 20.09-1.11 35 12 25.46 6.95 37.5 30.5 1.26 5.69-1 11-3.38 3.79-7.5 6.5 5.74 10.07 1.5 20.5-7.55 7.47-17.5 3.5-11.01-5.34-22.5-9.5-18.26 10-38.5 13-15.5 0-31 0-26.62-4.54-51-17-4.17 1.33-8 3.5-7.23 5.87-15 11-8.62 2.58-13.5-4.5-1.82 2.32-4.5 3.5-6.06 2.24-12 3.5-7.5 0-15 0-27.42-2.56-50-18.5-18-17.25-23-41.5 0-11.5 0-23 4.12-22.7 25-33 6.95-16.67 22-26.5-20.39-20.8-14.5-49.5 7.01-26.98 28.5-44.5 7.56-5.27 15-10.5-13.09-30.88-7.5-64 3.16-15.57 14.5-26.5 6.85-2.48 8 4.5-6.59 39.53 11 75.5 7.99-0.49 16-2 2.42-34.57 14.5-67.5 8.51-22.23 27.5-36z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s1" d="m113.5 401.5q0.48-5.1-1-10-0.91 0.19-1 1-2.46 1.74-5 3.5 5.65 9.54-5 13-32.21 5.55-61-10-32.89-23.11-29.5-63.5 2.96-22.67 23.5-32 7.99-19.75 27-29.5-27.65-23.7-15.5-58.5 7.33-16.82 20.5-29.5 10.79-8.14 22-15.5-16.49-37.08-5.5-76 3.19-6.13 7.5-11.5 1.48-0.89 2 1-5.69 41.09 12.5 78.5 1 1 2 2 9.97-3.24 20.5-4 2 0 4 0 0-7.5 0-15 0.99-42.22 24.5-77 6.12-7.12 14-12-4.65 13.43-10 27-11.93 37.6-9.5 77 49.38 0.7 83.5 36 2.75 4.5 5.5 9 38.99-52.24 93-88.5 45.84-29.03 100-32.5 15.69-1.56 29 6.5 5.68 7.29 3.5 16.5-10.38 33.62-43.5 45-4.39 37.33-41 45-0.79 8.63-6 15.5 1.91 1.83 4.5 2.5 22.27-17.25 50.5-14.5 12.93-9.41 28-15 36.22-8.28 31.5 28.5-15.19 51.69-62.5 77.5-65.92 35.87-138 15.5-19.67 10.42-42 10.5-8.39 2.88-17 5 3.58 6.08 10 9 20.92-1.14 36 13 22.67 5.23 34.5 25.5 3.33 7.13-3.5 11.5-3.88 1.8-8 3 7.36 8.45 6.5 19.5-4.43 5.66-11.5 3.5-12.84-5.67-26-10.5-39.4 21.02-83 10.5-18.85-5.78-36.5-14.5-13.65 4.14-23.5 14.5-9.51 3.74-11-6.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s2" d="m153.5 173.5q24.62 1.46 46 13.5 12.11 8.1 17.5 21.5 0.74 2.45 0.5 5 0.09 0.81 1 1 1.48-4.9 1-10 5.04 10.48 1.5 22-9.81 27.86-35.5 42.5-26.17 14.97-56 19.5-2.77-0.4-2 1 2.86 1.27 6 1 25.64 1.53 48.5-10 0.34 10.08 2 20 1.08 5.76 5 10 1 1.5 0 3-31.11 20.84-68.5 17.5-23.7-5.7-32.5-28.5-4.39-9.18-3.5-19 15.41 6.23 32 4.5-20.68-6.39-39-18-34.81-27.22-12.5-65.5 11.84-14.83 29-23 4.21 7.66 11.5 12.5 3 1 6 0-26.04-34.62-29-78-0.13-8.46 2-16.5 1 6.5 2 13 3.43 39.53 24.5 73 2.03 2.28 4.5 4 0.5-1.25 1-2.5-1.27-6.54-5-12 0.5-0.75 1-1.5 9.72-3.43 20-4 0.55 10.34 8 17.5 1.94 0.74 4 0.5-17.8-64.6 16.5-122 0.98-1.79 1.5 0-28.21 56.64-13.5 118 1.08 1.43 2.5 0.5 2.21-4.98 2-10.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s3" d="m454.5 97.5q-18.37-2.97-37-1.5-16.14 2.08-32 5.5 32.38-14.09 67-7.5 1.98 1.22 2 3.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s4" d="m454.5 97.5q-1.33 11.18-8.5 20-21.81 26.28-55.5 32-1.11-0.2-2 0.5 2.31 2.82 5.5 4.5 1 2 0 4-9.56 11.3-19.5 20 19.71-8.72 31-27 2.68-0.43 5 1-14.24 30.97-48 36.5-9.93 1.71-20 1.5-6.8-0.48-13 1 5.81 6.92 14 11-10.78 16.03-27 26.5 27.16-7.4 38-33.5 4.34 1.35 9 1-9.08 23.84-33 33.5-18.45 6.41-38 7 22.59 8.92 45-1 12.05-5.52 24-11 9.01-1.79 17 2.5 5.28-4.38 11-8 12.8-6.07 27-5 0 0.5 0 1-19.34 2.69-34 15.5 0.5 0.25 1 0.5 17.79-8.09 36-15 2.71-0.79 5-2 2.5-1 5-2 5.53-4.04 11-8 11.7-4.18 24-6.5 7.78-1.36 15 1.5-2.97 18.45-13.5 34-34.92 49.37-94.5 62.5-59.27 12.45-108-23-15.53-12.52-21.5-31.5-2.47-14.26 4-27-3.15 24.41 14 42-4.92-10.28-7-22-1.97-17.63 7-33 47.28-69.5 125.5-100 15.86-3.42 32-5.5 18.63-1.47 37 1.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s5" d="m86.5 112.5q-1-6.5-2-13 0.7-5.34 3.5-10-1.8 11.32-1.5 23z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s6" d="m433.5 97.5q2.22-0.39 4 1-10 13.75-27 14-0.24-2.06 0.5-4 10.3-7.78 22.5-11z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s7" d="m407.5 101.5q2.55-0.24 5 0.5-52.87 18.31-84.5 64.5-6.94 7.95-17 11-9.38-2.38-5-11 40.38-48.62 101.5-65z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s8" d="m402.5 112.5q3 0 6 0-2.56 8.8-12 7-0.22-1.58 0.5-3 2.72-2.22 5.5-4z"/>
 	</g>
 	<g>
 	</g>
 	<g>
 	</g>
 	<g>
 	</g>
 	<g>
 	</g>
 	<g>
 	</g>
 	<g>
 	</g>
 	<g>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s9" d="m390.5 149.5q7.77 0.52 15 2-11.29 18.28-31 27 9.94-8.7 19.5-20 1-2 0-4-3.19-1.68-5.5-4.5 0.89-0.7 2-0.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s10" d="m131.5 145.5q0 7.5 0 15-2 0-4 0 1.06-1.36 3-1-0.48-7.29 1-14z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s11" d="m219.5 204.5q-1 4.5-2 9 0.24-2.55-0.5-5-5.39-13.4-17.5-21.5-21.38-12.04-46-13.5 0-2 0-4 36.7-0.86 61.5 26 3.06 4.11 4.5 9z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s12" d="m329.5 191.5q6.2-1.48 13-1-3.5 1-7 2-2.9-0.97-6-1z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s13" d="m329.5 191.5q3.1 0.03 6 1 9.55 1.31 19 3-10.84 26.1-38 33.5 16.22-10.47 27-26.5-8.19-4.08-14-11z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s14" d="m479.5 199.5q-7.22-2.86-15-1.5-12.3 2.32-24 6.5 15.6-13.11 36-11.5 3.63 2.26 3 6.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s15" d="m193.5 216.5q-12.01 1.52-22 8-2.83 1.29-5.5 3-4.79-4.57-6.5-11-5.04 2.2-9.5-1-3.47-6.4 3.5-3 4.4 0.05 8-2.5 9.22-9.73 21-16 6.3-3.24 12 1-2.9 1.22-6 1.5 2.61 5.74 4.5 12 0.75 3.97 0.5 8z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s16" d="m458.5 200.5q3.04-0.24 6 0.5-18.02 7.05-33 19-1 1-2 0 11.53-14.3 29-19.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s17" d="m178.5 202.5q6.85-0.63 4.5 6-7.6 5.09-6-4 1.08-0.82 1.5-2z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s18" d="m469.5 201.5q-2.26 13.65-14.5 22-0.47-2.11 1-4 7.08-8.82 13.5-18z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s19" d="m74.5 208.5q8.22-0.2 16 2.5 11.8 4.26 23.5 8.5 5.65-0.63 8-6 2.41 11.83-9.5 13 0.55 3.61 2 7-0.5 1-1 2-4.67-0.94-9.5-1-9.96 0.44-19.5 2.5-5.05-3.55-6.5-9.5-0.75-7.48-0.5-15-6.47 0.15-3-4z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s20" d="m429.5 212.5q-2.5 1-5 2-4 0-8 0-14.2-1.07-27 5 15.27-12.44 35-9.5 2.72 1.14 5 2.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s21" d="m219.5 204.5q0.48 5.1-1 10-0.91-0.19-1-1 1-4.5 2-9z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s22" d="m416.5 215.5q0-0.5 0-1 4 0 8 0-2.29 1.21-5 2-1.06-1.36-3-1z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s23" d="m416.5 215.5q1.94-0.36 3 1-18.21 6.91-36 15-0.5-0.25-1-0.5 14.66-12.81 34-15.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s24" d="m193.5 216.5q4.39 1.3 9 3-0.79 1.04-2 1.5-14.77-0.13-29 3.5 9.99-6.48 22-8z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s25" d="m98.5 219.5q6.09-0.98 6 5-3.04 0.24-6-0.5-1.84-2.24 0-4.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s26" d="m176.5 229.5q8.85-1.14 16 4-4.98 1.75-10 0-13.56 14.3-33 19.5-28.06 8.2-55 1 3.32-6.4 10-5.5-0.71 1.47-2 2.5 36.58 4.24 69-14 4.68-2.13 1-5 2.35-0.91 4-2.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s27" d="m231.5 238.5q1.31-0.2 2 1-3.13 28.62 15 51-16.25 6.75-27-7.5-1-1-2 0 14.73 29.34 46 18.5 1.79 0.52 0 1.5-37.63 16.82-50.5-22.5-5.1-26.48 16.5-42z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s28" d="m243.5 259.5q5.88 3.62 10.5 9 12.96 18.46 32.5 29.5-31.51-7.75-43-38.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s29" d="m203.5 266.5q1.31-0.2 2 1-2.48 22.08 12 39-6.99 1.35-14 0.5 4.59 4.08 10 7-8.71 0.28-14.5-6.5-16.98-22.76 4.5-41z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s27" d="m58.5 284.5q9.6-2.17 14.5 6 5.15 14.18-1 28-11.05-13.14-27.5-17.5 5.15-9.9 14-16.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s30" d="m129.5 288.5q2 1 4 2-3.14 0.27-6-1-0.77-1.4 2-1z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s31" d="m56.5 313.5q3.43 5.43 8 10-4.88 0.44-8 4-1.11-0.2-2 0.5 28.91 1.65 38 28.5 0.45 3.16-1 6-11.02-7.01-23-12.5-4.75-3.75-9.5-7.5 1.47 7.42 7 13 8.34 27.18 32 43 0.99 2.41-1.5 3.5-40.25 5.58-66.5-25.5-15.67-22.01-8-48 10.46-23.87 34.5-15z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s32" d="m45.5 317.5q4.03-0.25 8 0.5 2.46 4.16-2 6-6.04 2.01-9-3.5 1.26-1.85 3-3z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s33" d="m56.5 313.5q4.91 3.14 9.5 7 0.88 2.25-1.5 3-4.57-4.57-8-10z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s34" d="m198.5 319.5q-11.1 11.56-27 15.5-15.75 4.88-32 2.5 28.81-3.69 54-18.5 2.65-0.96 5 0.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s4" d="m198.5 319.5q1.44 0.68 2.5 2 2.41 8.23 6 16 1.2 2.64-0.5 5-30.65 21.41-68 18.5-25.16-6.17-32.5-30.5 6.96 4.99 15.5 6.5 8.99 0.75 18 0.5 16.25 2.38 32-2.5 15.9-3.94 27-15.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s35" d="m92.5 356.5q-9.09-26.85-38-28.5 0.89-0.7 2-0.5 25.47-4.89 35.5 19 0.75 4.98 0.5 10z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s36" d="m72.5 335.5q3.62-0.38 5 3-4.22 1.83-5-3z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s37" d="m223.5 336.5q5.59-0.48 11 1-4.04 4.16-8.5 8-5.99-3.8-2.5-9z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s38" d="m90.5 334.5q0.59-1.54 2-0.5 3.94 5.45 9 10 7 6 14 12-6.91-1.7-13-6-6.21-7.72-12-15.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s39" d="m261.5 346.5q-3.54-2.44-8-3.5-6.98-0.75-14-0.5 0.63-1.08 2-1.5 13.82-2.52 26 4-2.63 1.98-6 1.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s40" d="m239.5 342.5q7.02-0.25 14 0.5 4.46 1.06 8 3.5-5.2 2.35-10 5.5-3.88 4.65-9 7.5-9.89-3.09-9.5-13 2.36-3.63 6.5-4z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s41" d="m214.5 349.5q-21.43 15.48-48 16 22.82-5.9 43-18.5 3.64-1.12 5 2.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s42" d="m214.5 349.5q5.96 7.2 13.5 13 1 1 0 2-28.58 23.34-65.5 20.5-18.15-4.24-27.5-19.5 1.13 0.94 2.5 1.5 14.7 1.42 29-1.5 26.57-0.52 48-16z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s43" d="m302.5 373.5q-14.74-16.73-37-19-4.55 0.25-9 1 25.3-10.24 43.5 11 2.85 2.91 2.5 7z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s44" d="m302.5 373.5q0.21 2.44-2 3.5-28.69 7.6-50.5-12.5-0.06-6.71 6.5-9 4.45-0.75 9-1 22.26 2.27 37 19z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s45" d="m100.5 356.5q5.42 2.71 11 5.5-13.04 7.54-18.5 21.5-7.57-7.14-10.5-17 5.58 1.54 10 5.5 4.2 0.84 5.5-3.5 1.41-5.99 2.5-12z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s8" d="m83.5 394.5q-18.9-10.15-29.5-29-1.54-3.52-2-7 5.79 2.39 10 7 7.82 16.63 21.5 29z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s46" d="m232.5 365.5q17.6 6.19 10.5 23-10.6 10.42-25.5 11.5-25.94 3.21-49-9 36.75-1.65 64-25.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s47" d="m113.5 367.5q7.7-0.01 9.5 7-9.69 7.19-18.5 15.5-7.23 5.76-5.5-3.5 3.12-12.84 14.5-19z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s29" d="m126.5 380.5q7.88-0.4 12 6.5-8.5 7.25-17 14.5-5.62-12.55 5-21z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s48" d="m283.5 385.5q3.22 2.95 7 5.5 2.8 4.03 6 7.5 0.42 2.77-2 4-15.5-9.75-31-19.5-1.79-0.98 0-1.5 9.96 2.49 20 4z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s49" d="m283.5 385.5q8.71-1.27 11.5 7 1.22 2.9 1.5 6-3.2-3.47-6-7.5-3.78-2.55-7-5.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s50" d="m83.5 394.5q1.88-0.06 3 1.5-2.25 0.88-3-1.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s51" d="m258.5 392.5q3.51 0.41 0 2.5-2.33 1.93-5 2 2.61-2.28 5-4.5z"/>
 	</g>
 	<g>
 		<path fill-rule="evenodd" class="s52" d="m111.5 392.5q0.09-0.81 1-1 1.48 4.9 1 10-1-4.5-2-9z"/>
 	</g>
 </svg>
@@ -0,0 +1,7 @@
 <svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" height="512"><svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
 <rect width="512" height="512" fill="#131010"></rect>
 <path d="M320 224V352H192V224H320Z" fill="#5A5858"></path>
 <path fill-rule="evenodd" clip-rule="evenodd" d="M384 416H128V96H384V416ZM320 160H192V352H320V160Z" fill="white"></path>
 </svg><style>@media (prefers-color-scheme: light) { :root { filter: none; } }
@media (prefers-color-scheme: dark) { :root { filter: none; } }
 </style></svg>
@@ -0,0 +1 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 160 160"><rect width="160" height="160" rx="24" fill="#f7f7f7"/><g transform="translate(16 16)"><mask id="a" width="128" height="128" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#fff" fill-rule="evenodd" d="M90.767 127.126a7.968 7.968 0 0 0 6.35-.244l26.353-12.681a8 8 0 0 0 4.53-7.209V21.009a8 8 0 0 0-4.53-7.21L97.117 1.12a7.97 7.97 0 0 0-9.093 1.548l-50.45 46.026L15.6 32.013a5.328 5.328 0 0 0-6.807.302l-7.048 6.411a5.335 5.335 0 0 0-.006 7.888L20.796 64 1.74 81.387a5.336 5.336 0 0 0 .006 7.887l7.048 6.411a5.327 5.327 0 0 0 6.807.303l21.974-16.68 50.45 46.025a7.96 7.96 0 0 0 2.743 1.793Zm5.252-92.183L57.74 64l38.28 29.058V34.943Z" clip-rule="evenodd"/></mask><g mask="url(#a)"><path fill="#0065A9" d="M123.471 13.82 97.097 1.12A7.973 7.973 0 0 0 88 2.668L1.662 81.387a5.333 5.333 0 0 0 .006 7.887l7.052 6.411a5.333 5.333 0 0 0 6.811.303l103.971-78.875c3.488-2.646 8.498-.158 8.498 4.22v-.306a8.001 8.001 0 0 0-4.529-7.208Z"/><g filter="url(#b)"><path fill="#007ACC" d="m123.471 114.181-26.374 12.698A7.973 7.973 0 0 1 88 125.333L1.662 46.613a5.333 5.333 0 0 1 .006-7.887l7.052-6.411a5.333 5.333 0 0 1 6.811-.303l103.971 78.874c3.488 2.647 8.498.159 8.498-4.219v.306a8.001 8.001 0 0 1-4.529 7.208Z"/></g><g filter="url(#c)"><path fill="#1F9CF0" d="M97.098 126.882A7.977 7.977 0 0 1 88 125.333c2.952 2.952 8 .861 8-3.314V5.98c0-4.175-5.048-6.266-8-3.313a7.977 7.977 0 0 1 9.098-1.549L123.467 13.8A8 8 0 0 1 128 21.01v85.982a8 8 0 0 1-4.533 7.21l-26.369 12.681Z"/></g><path fill="url(#d)" fill-rule="evenodd" d="M90.69 127.126a7.968 7.968 0 0 0 6.349-.244l26.353-12.681a8 8 0 0 0 4.53-7.21V21.009a8 8 0 0 0-4.53-7.21L97.039 1.12a7.97 7.97 0 0 0-9.093 1.548l-50.45 46.026-21.974-16.68a5.328 5.328 0 0 0-6.807.302l-7.048 6.411a5.336 5.336 0 0 0-.006 7.888L20.718 64 1.662 81.386a5.335 5.335 0 0 0 .006 7.888l7.048 6.411a5.328 5.328 0 0 0 6.807.303l21.975-16.681 50.45 46.026a7.959 7.959 0 0 0 2.742 1.793Zm5.252-92.184L57.662 64l38.28 29.057V34.943Z" clip-rule="evenodd" opacity="0.25" style="mix-blend-mode:overlay"/></g><defs><filter id="b" width="144.744" height="113.408" x="-8.41115" y="22.5944" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feColorMatrix in="SourceAlpha" result="hardAlpha" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"/><feOffset/><feGaussianBlur stdDeviation="4.16667"/><feColorMatrix values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/><feBlend in2="BackgroundImageFix" mode="overlay" result="effect1_dropShadow_1_36"/><feBlend in="SourceGraphic" in2="effect1_dropShadow_1_36" result="shape"/></filter><filter id="c" width="56.6667" height="144.007" x="79.6667" y="-8.0035" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feColorMatrix in="SourceAlpha" result="hardAlpha" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"/><feOffset/><feGaussianBlur stdDeviation="4.16667"/><feColorMatrix values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/><feBlend in2="BackgroundImageFix" mode="overlay" result="effect1_dropShadow_1_36"/><feBlend in="SourceGraphic" in2="effect1_dropShadow_1_36" result="shape"/></filter><linearGradient id="d" x1="63.9222" x2="63.9222" y1="0.329902" y2="127.67" gradientUnits="userSpaceOnUse"><stop stop-color="#fff"/><stop offset="1" stop-color="#fff" stop-opacity="0"/></linearGradient></defs></g></svg>
@@ -4,45 +4,9 @@ title: Importing a Model
 ## Table of Contents
- [Importing a Safetensors adapter](#Importing-a-fine-tuned-adapter-from-Safetensors-weights)
+- [Importing a Safetensors model](#importing-a-model-from-safetensors-weights)
- [Importing a Safetensors model](#Importing-a-model-from-Safetensors-weights)
+- [Importing a GGUF model](#importing-a-gguf-model)
- [Importing a GGUF file](#Importing-a-GGUF-based-model-or-adapter)
+- [Sharing models on ollama.com](#sharing-your-model-on-ollama-com)
 - [Sharing models on ollama.com](#Sharing-your-model-on-ollamacom)
 ## Importing a fine tuned adapter from Safetensors weights
 First, create a `Modelfile` with a `FROM` command pointing at the base model you used for fine tuning, and an `ADAPTER` command which points to the directory with your Safetensors adapter:
 ```dockerfile
 FROM <base model name>
 ADAPTER /path/to/safetensors/adapter/directory
 ```
 Make sure that you use the same base model in the `FROM` command as you used to create the adapter otherwise you will get erratic results. Most frameworks use different quantization methods, so it's best to use non-quantized (i.e. non-QLoRA) adapters. If your adapter is in the same directory as your `Modelfile`, use `ADAPTER .` to specify the adapter path.
 Now run `ollama create` from the directory where the `Modelfile` was created:
 ```shell
 ollama create my-model
 ```
 Lastly, test the model:
 ```shell
 ollama run my-model
 ```
 Ollama supports importing adapters based on several different model architectures including:
 - Llama (including Llama 2, Llama 3, Llama 3.1, and Llama 3.2);
 - Mistral (including Mistral 1, Mistral 2, and Mixtral); and
 - Gemma (including Gemma 1 and Gemma 2)
 You can create the adapter using a fine tuning framework or tool which can output adapters in the Safetensors format, such as:
 - Hugging Face [fine tuning framework](https://huggingface.co/docs/transformers/en/training)
 - [Unsloth](https://github.com/unslothai/unsloth)
 - [MLX](https://github.com/ml-explore/mlx)
 ## Importing a model from Safetensors weights
@@ -66,81 +30,28 @@ Lastly, test the model:
 ollama run my-model
 ```
-Ollama supports importing models for several different architectures including:
+## Importing a GGUF model
- Llama (including Llama 2, Llama 3, Llama 3.1, and Llama 3.2);
+Ollama does not quantize GGUF models during import. Prepare and quantize them first with a GGUF tool such as llama.cpp's [`llama-quantize`](https://github.com/ggml-org/llama.cpp/tree/master/tools/quantize).
 - Mistral (including Mistral 1, Mistral 2, and Mixtral);
 - Gemma (including Gemma 1 and Gemma 2); and
 - Phi3
-This includes importing foundation models as well as any fine tuned models which have been _fused_ with a foundation model.
+To import a single-file GGUF model, create a `Modelfile` containing:
 ## Importing a GGUF based model or adapter
 If you have a GGUF based model or adapter it is possible to import it into Ollama. You can obtain a GGUF model or adapter by:
 - converting a Safetensors model with the `convert_hf_to_gguf.py` from Llama.cpp;
 - converting a Safetensors adapter with the `convert_lora_to_gguf.py` from Llama.cpp; or
 - downloading a model or adapter from a place such as HuggingFace
 To import a GGUF model, create a `Modelfile` containing:
 ```dockerfile
 FROM /path/to/file.gguf
 ```
-For a GGUF adapter, create the `Modelfile` with:
+For a split GGUF model, keep the original split filenames and use a wildcard that matches every shard.
 ```dockerfile
-FROM <model name>
+FROM /path/to/model-*.gguf
 ADAPTER /path/to/file.gguf
 ```
 When importing a GGUF adapter, it's important to use the same base model as the base model that the adapter was created with. You can use:
 - a model from Ollama
 - a GGUF file
 - a Safetensors based model
 Once you have created your `Modelfile`, use the `ollama create` command to build the model.
 ```shell
 ollama create my-model
 ```
 ## Quantizing a Model
 Quantizing a model allows you to run models faster and with less memory consumption but at reduced accuracy. This allows you to run a model on more modest hardware.
 Ollama can quantize FP16 and FP32 based models into different quantization levels using the `-q/--quantize` flag with the `ollama create` command.
 First, create a Modelfile with the FP16 or FP32 based model you wish to quantize.
 ```dockerfile
 FROM /path/to/my/gemma/f16/model
 ```
 Use `ollama create` to then create the quantized model.
 ```shell
 $ ollama create --quantize q4_K_M mymodel
 transferring model data
 quantizing F16 model to Q4_K_M
 creating new layer sha256:735e246cc1abfd06e9cdcf95504d6789a6cd1ad7577108a70d9902fef503c1bd
 creating new layer sha256:0853f0ad24e5865173bbf9ffcc7b0f5d56b66fd690ab1009867e45e7d2c4db0f
 writing manifest
 success
 ```
 ### Supported Quantizations
 - `q8_0`
 #### K-means Quantizations
 - `q4_K_S`
 - `q4_K_M`
 ## Sharing your model on ollama.com
 You can share any model you have created by pushing it to [ollama.com](https://ollama.com) so that other users can try it out.
@@ -1,58 +1,40 @@
 ---
-title: Ollama's documentation
+title: Ollama documentation
 sidebarTitle: Welcome
 ---
-<img src="/images/welcome.png" noZoom className="rounded-3xl" />
+Use open models in your desktop apps and coding agents, or build them into your application.
 [Ollama](https://ollama.com) is the easiest way to get up and running with large language models such as gpt-oss, Gemma 3, DeepSeek-R1, Qwen3 and more.
 <CardGroup cols={2}>
-  <Card title="Quickstart" icon="rocket" href="/quickstart">
+  <Card title="Use your apps" icon="desktop" href="/quickstart#get-started">
-    Get up and running with your first model or integrate Ollama with your favorite tools
+    Connect Claude or ChatGPT on your desktop, or launch a coding agent from your terminal.
  </Card>
-  <Card
+  <Card title="Build an application" icon="code" href="/quickstart#build-an-application">
-    title="Download Ollama"
+    Call cloud models with Ollama, OpenAI, or Anthropic APIs.
    icon="download"
    href="https://ollama.com/download"
  >
    Download Ollama on macOS, Windows or Linux
  </Card>
  <Card title="Cloud" icon="cloud" href="/cloud">
    Ollama's cloud models offer larger models with better performance.
  </Card>
  <Card title="API reference" icon="terminal" href="/api">
    View Ollama's API reference
  </Card>
 </CardGroup>
-## Libraries
+## Explore models
 Choose cloud models or run models on your computer.
 <CardGroup cols={2}>
-  <Card
+  <Card title="Cloud models" icon="cloud" href="/cloud">
-    title="Ollama's Python Library"
+    Run models without a local GPU.
    icon="python"
    href="https://github.com/ollama/ollama-python"
  >
    The official library for using Ollama with Python
  </Card>
-
+  <Card title="Local models" icon="hard-drive" href="/quickstart#run-a-model-locally">
-  <Card title="Ollama's JavaScript library" icon="js" href="https://github.com/ollama/ollama-js">
+    Download Ollama and run a model on your computer.
    The official library for using Ollama with JavaScript or TypeScript.
  </Card>
  <Card title="Community libraries" icon="github" href="https://github.com/ollama/ollama?tab=readme-ov-file#libraries-1">
    View a list of 20+ community-supported libraries for Ollama
  </Card>
 </CardGroup>
 Browse the [model library](https://ollama.com/search) for coding, vision, embeddings, and reasoning models.
 ## Documentation
 - [Integrations](/integrations) — connect an app, editor, or agent.
 - [API reference](/api/introduction) — use Ollama's API or compatible OpenAI and Anthropic clients.
 - [Python library](https://github.com/ollama/ollama-python) and [JavaScript library](https://github.com/ollama/ollama-js) — use Ollama from your application.
 ## Community
-<CardGroup cols={2}>
+Join the conversation on [Discord](https://discord.gg/ollama) or [Reddit](https://reddit.com/r/ollama).
  <Card title="Discord" icon="discord" href="https://discord.gg/ollama">
    Join our Discord community
  </Card>
  <Card title="Reddit" icon="reddit" href="https://reddit.com/r/ollama">
    Join our Reddit community
  </Card>
 </CardGroup>
@@ -0,0 +1,39 @@
 ---
 title: ChatGPT Desktop
 description: Use Ollama models in ChatGPT Desktop.
 ---
 ChatGPT Desktop includes Codex, OpenAI's desktop coding agent. Ollama adds compatible local and cloud models to Codex's model picker alongside ChatGPT's native models.
 ## Prerequisites
 - Ollama v0.34.0 or newer
 If ChatGPT is not installed, Ollama offers to download it during setup.
 ## Connect ChatGPT
 1. Open the Ollama desktop app and select **Apps**.
 2. Toggle **ChatGPT (Desktop)** to On.
 3. Follow the setup prompts. If ChatGPT is already open, Ollama asks to restart it before the new models appear.
 4. Open the ChatGPT desktop app and use Codex mode.
 ## Choose models
 Open Ollama **Settings**, select **Apps**, then select ChatGPT. Choose up to five compatible local or cloud models and save your changes. Ollama asks to restart ChatGPT when a model change needs one.
 ## Disconnect ChatGPT
 Open Ollama **Apps** and turn ChatGPT off. Ollama restores ChatGPT's connection settings and usual profile. If ChatGPT is open, Ollama asks to restart it so the change takes effect.
 ## Codex behavior and limits
 - Only requests made with an Ollama model go to Ollama. ChatGPT's native models keep using their usual provider.
 - Ollama models are for Codex mode. Regular Chat and voice keep using their usual ChatGPT connection.
 - Codex manages sessions. Ollama routes model requests and compaction when Codex asks for it, but does not store ChatGPT sessions.
 - Web search uses Ollama's web-search service when you use an Ollama model. It requires Ollama sign-in and is limited to three calls per response.
 ## Related integrations
 - Use Codex from a terminal with [Codex CLI](/integrations/codex).
 - Connect other desktop apps from [Claude Desktop](/integrations/claude-desktop).
@@ -2,15 +2,179 @@
 title: Claude Code
 ---
-Claude Code is Anthropic's agentic coding tool that can read, modify, and execute code in your working directory. 
+[Claude Code](https://code.claude.com/docs/en/overview) reads your codebase, edits files, and runs commands.
-Open models can be used with Claude Code through Ollama's Anthropic-compatible API, enabling you to use models such as `qwen3.5`, `glm-5:cloud`, `kimi-k2.5:cloud`.
+Ollama connects Claude Code to local and cloud models through its Anthropic-compatible API.
-![Claude Code with Ollama](https://files.ollama.com/claude-code.png)
+## Get started
-## Install
+Launch Claude Code with Ollama:
-Install [Claude Code](https://code.claude.com/docs/en/overview):
+```shell
 ollama launch claude
 ```
 ## Capabilities
 <div className="capability-list capability-list-full">
  <div className="capability-list-grid">
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="comment" /></div>
      <div>
        <div className="capability-list-heading">Chat</div>
        <div className="capability-list-copy">Ask questions about a repository or task</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="terminal" /></div>
      <div>
        <div className="capability-list-heading">Command line</div>
        <div className="capability-list-copy">Run commands with Claude Code's permission flow</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="code" /></div>
      <div>
        <div className="capability-list-heading">Tool calling</div>
        <div className="capability-list-copy">Use tools with compatible models</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="file-pen" /></div>
      <div>
        <div className="capability-list-heading">File edits</div>
        <div className="capability-list-copy">Read and edit files in your project</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="users" /></div>
      <div>
        <div className="capability-list-heading">Subagents</div>
        <div className="capability-list-copy">Split work across tasks</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="globe" /></div>
      <div>
        <div className="capability-list-heading">Web search</div>
        <div className="capability-list-copy">Search the web through Ollama</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="file-text" /></div>
      <div>
        <div className="capability-list-heading">Web fetch</div>
        <div className="capability-list-copy">Fetch and summarize web pages</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="image" /></div>
      <div>
        <div className="capability-list-heading">Vision</div>
        <div className="capability-list-copy">Send images and screenshots</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="brain" /></div>
      <div>
        <div className="capability-list-heading">Thinking</div>
        <div className="capability-list-copy">Use thinking controls with compatible models</div>
      </div>
    </div>
  </div>
 </div>
 ## Models
 Choose a model with enough context for your repository.
 <CardGroup cols={2}>
  <Card title="Cloud models" icon="cloud" href="https://ollama.com/search?c=cloud">
    Use larger models without downloading them.
  </Card>
  <Card title="Local models" icon="hard-drive" href="https://ollama.com/search?c=tools">
    Choose a model and set a 64k+ context window.
  </Card>
 </CardGroup>
 <Note>For larger repositories, set the [context length](/context-length) to 64k or higher.</Note>
 ## More features
 ### Run without interaction
 Use `--yes` for scripts, Docker, or CI:
 ```shell
 ollama launch claude --model gemma4:cloud --yes -- -p "how does this repository work?"
 ```
 The `--yes` flag skips selectors, pulls the model when needed, and requires `--model`. Arguments after `--` are passed directly to Claude Code.
 ### Web search
 Use Ollama's web search API from Claude Code.
 See [Web search](/capabilities/web-search) for setup and usage.
 ### Scheduled tasks with `/loop`
 Use `/loop` inside Claude Code to run a prompt or slash command on a schedule:
 ```text
 /loop <interval> <prompt or /command>
 ```
 Examples:
 ```text
 /loop 30m Check my open PRs and summarize their status
 /loop 1h Research the latest AI news and summarize key developments
 /loop 15m Check for new GitHub issues and triage by priority
 ```
 ### Telegram
 Connect a Telegram bot to your Claude Code session. Install the [Telegram plugin](https://github.com/anthropics/claude-plugins-official), create a bot with [@BotFather](https://t.me/BotFather), then launch Claude Code:
 ```shell
 ollama launch claude -- --channels plugin:telegram@claude-plugins-official
 ```
 Claude Code prompts for permission on most actions. To allow the bot to work autonomously, configure [permission rules](https://code.claude.com/docs/en/permissions) or pass `--dangerously-skip-permissions` in an isolated environment.
 See the [plugin README](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram) for setup instructions.
 ## Connect directly to Ollama Cloud
 Install Claude Code, then set your [API key](/quickstart#build-an-application) in `OLLAMA_API_KEY`. No Ollama installation required.
 In Bash or Zsh, run:
 ```shell
 ANTHROPIC_BASE_URL=https://ollama.com \
 ANTHROPIC_AUTH_TOKEN="$OLLAMA_API_KEY" \
 ANTHROPIC_API_KEY="" \
 claude --model glm-5.3-flash
 ```
 Use `ANTHROPIC_AUTH_TOKEN` for bearer authentication. Claude settings can override shell variables. Update any base URL or credentials in those settings, then run `/status` to check the connection.
 Choose a [cloud model](https://ollama.com/search?c=cloud) that supports tools. Basic chat and file edits work with compatible models. Hosted WebSearch and advanced tool controls are not fully supported. See [Anthropic compatibility](/api/anthropic-compatibility).
 ## Manual setup
 <p className="manual-step-title">1. Install Claude Code</p>
 <CodeGroup>
@@ -24,95 +188,7 @@ irm https://claude.ai/install.ps1 | iex
 </CodeGroup>
-## Usage with Ollama
+<p className="manual-step-title">2. Set the environment variables</p>
 ### Quick setup
 ```shell
 ollama launch claude
 ```
 ### Run directly with a model
 ```shell
 ollama launch claude --model kimi-k2.5:cloud
 ```
 ## Recommended Models
 - `kimi-k2.5:cloud`
 - `glm-5:cloud`
 - `minimax-m2.7:cloud`
 - `qwen3.5:cloud`
 - `glm-4.7-flash`
 - `qwen3.5`
 Cloud models are also available at [ollama.com/search?c=cloud](https://ollama.com/search?c=cloud).
 ## Non-interactive (headless) mode
 Run Claude Code without interaction for use in Docker, CI/CD, or scripts:
 ```shell
 ollama launch claude --model kimi-k2.5:cloud --yes -- -p "how does this repository work?"
 ```
 The `--yes` flag auto-pulls the model, skips selectors, and requires `--model` to be specified. Arguments after `--` are passed directly to Claude Code.
 ## Web search
 Claude Code can search the web through Ollama's web search API. See the [web search documentation](/capabilities/web-search) for setup and usage.
 ## Scheduled Tasks with `/loop`
 The `/loop` command runs a prompt or slash command on a recurring schedule inside Claude Code. This is useful for automating repetitive tasks like checking PRs, running research, or setting reminders.
 ```
 /loop <interval> <prompt or /command>
 ```
 ### Examples
 **Check in on your PRs**
 ```
 /loop 30m Check my open PRs and summarize their status
 ```
 **Automate research tasks**
 ```
 /loop 1h Research the latest AI news and summarize key developments
 ```
 **Automate bug reporting and triaging**
 ```
 /loop 15m Check for new GitHub issues and triage by priority
 ```
 **Set reminders**
 ```
 /loop 1h Remind me to review the deploy status
 ```
 ## Telegram
 Chat with Claude Code from Telegram by connecting a bot to your session. Install the [Telegram plugin](https://github.com/anthropics/claude-plugins-official), create a bot via [@BotFather](https://t.me/BotFather), then launch with the channel flag:
 ```shell
 ollama launch claude -- --channels plugin:telegram@claude-plugins-official
 ```
 Claude Code will prompt for permission on most actions. To allow the bot to work autonomously, configure [permission rules](https://code.claude.com/docs/en/permissions) or pass `--dangerously-skip-permissions` in isolated environments.
 See the [plugin README](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram) for full setup instructions including pairing and access control.
 ## Manual setup
 Claude Code connects to Ollama using the Anthropic-compatible API.
 1. Set the environment variables:
 ```shell
 export ANTHROPIC_AUTH_TOKEN=ollama
@@ -120,7 +196,7 @@ export ANTHROPIC_API_KEY=""
 export ANTHROPIC_BASE_URL=http://localhost:11434
 ```
-2. Run Claude Code with an Ollama model:
+<p className="manual-step-title">3. Run Claude Code</p>
 ```shell
 claude --model qwen3.5
@@ -129,8 +205,5 @@ claude --model qwen3.5
 Or run with environment variables inline:
 ```shell
-ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY="" claude --model glm-5:cloud
+ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY="" claude --model kimi-k2.7-code:cloud
 ```
 **Note:** Claude Code requires a large context window. We recommend at least 64k tokens. See the [context length documentation](/context-length) for how to adjust context length in Ollama.
@@ -1,13 +1,42 @@
 ---
 title: Claude Desktop
 description: Use Ollama models in Claude on macOS.
 ---
 Claude Desktop is no longer supported by `ollama launch`.
-Existing installations can be restored to the usual Claude profile:
+## Prerequisites
 - [Ollama](https://ollama.com/download/). Windows support coming soon.
 - To use a local model, [download it](/quickstart#run-a-model-locally) before setup.
 - To use a cloud model, sign in to Ollama and enable cloud models. Some models require a [paid plan](https://ollama.com/pricing).
 If Claude is not installed, Ollama offers to download it during setup.
 ## Set up Claude
 1. Open Ollama and select **Apps**.
 2. Connect **Claude**.
 3. Follow the setup prompts to install Claude if needed and restart it when prompted.
 ## Switch models
 Open Ollama **Settings → Apps**. Choose your models, then select **Restart Claude**. You can use the same model for more than one option.
 ## Supported features
 - **Subagents** - Split larger tasks across agents
 - **Web search** - Supported by default through [Ollama's web search](/capabilities/web-search)
 - **Cowork** - Complete difficult tasks with Claude Cowork 
 - **Auto mode** - Let the agent decide when to ask before making changes
 ## Disconnect Claude
 Open Ollama **Apps** and disconnect Claude. Ollama restores Claude's previous settings. Restart Claude when prompted.
 You can also restore Claude from the terminal:
 ```shell
 ollama launch claude-desktop --restore
 ```
-Use [Claude Code](/integrations/claude-code) for Anthropic-compatible coding workflows with Ollama.
+Quitting Ollama while Claude is connected also restores Claude's usual configuration.
@@ -0,0 +1,98 @@
 ---
 title: Cline CLI
 ---
 Cline CLI is an autonomous coding agent for interactive terminal sessions.
 <img
  src="/images/cline-cli.png"
  alt="Cline CLI launched with Ollama selected as the provider"
  style={{ borderRadius: "12px" }}
 />
 ## Install
 Install the [Cline CLI](https://docs.cline.bot/usage/cli-overview). For the IDE extension, see [Cline](/integrations/cline).
 ```bash
 npm install -g cline
 ```
 <Note>If Cline CLI is not installed and `npm` is available, `ollama launch cline` will prompt to install `cline@latest`.</Note>
 ## Usage with Ollama
 ### Quick setup
 ```bash
 ollama launch cline
 ```
 When launched through `ollama launch cline`, Ollama sets Cline's provider to Ollama, points it at the local Ollama endpoint, and selects the model you choose.
 To configure without launching:
 ```shell
 ollama launch cline --config
 ```
 ### Run directly with a model
 ```shell
 ollama launch cline --model qwen3.5
 ```
 To use a cloud model:
 ```shell
 ollama launch cline --model kimi-k2.6:cloud
 ```
 ### Pass a prompt to Cline
 Arguments after `--` are passed directly to Cline:
 ```shell
 ollama launch cline -- "summarize this repository"
 ```
 To open Cline's Kanban board:
 ```shell
 ollama launch cline -- kanban
 ```
 <img
  src="/images/cline-kanban.png"
  alt="Cline Kanban board opened from the CLI"
  style={{ borderRadius: "12px" }}
 />
 ### Manual setup
 To configure Cline CLI manually, first make sure Ollama is running and the model you want to use is available:
 ```shell
 ollama pull qwen3.5
 ```
 Then run Cline's interactive auth flow:
 ```shell
 cline auth
 ```
 Select Ollama as the provider, use `http://localhost:11434` as the base URL if prompted, and choose a model such as `qwen3.5` or `kimi-k2.6:cloud`.
 To check the current Cline configuration:
 ```shell
 cline config
 ```
 To start an interactive session:
 ```shell
 cline
 ```
@@ -13,7 +13,7 @@ Install [Cline](https://docs.cline.bot/getting-started/installing-cline) in your
 2. Select a model under `Model` or type one (e.g. `qwen3`)
 3. Update the context window to at least 32K tokens under `Context Window`
-<Note>Coding tools require a larger context window. It is recommended to use a context window of at least 32K tokens. See [Context length](/context-length) for more information.</Note>
+<Note>Use a [context window](/context-length) of at least 32K tokens for coding.</Note>
 <div style={{ display: 'flex', justifyContent: 'center' }}>
  <img 
@@ -32,7 +32,6 @@ Install [Cline](https://docs.cline.bot/getting-started/installing-cline) in your
 4. Select a model from the list
-### Recommended Models
+### Models
- `qwen3-coder:480b` 
+Choose a [cloud model](https://ollama.com/search?c=cloud) that supports tool calling.
 - `deepseek-v3.1:671b`
@@ -1,11 +1,11 @@
 ---
-title: Codex
+title: Codex CLI
 ---
 ## Install
-Install the [Codex CLI](https://developers.openai.com/codex/cli/):
+Install the [Codex CLI](https://developers.openai.com/codex/cli/). For the ChatGPT desktop app, see [ChatGPT Desktop](/integrations/chatgpt).
 ```
 npm install -g @openai/codex
@@ -13,7 +13,7 @@ npm install -g @openai/codex
 ## Usage with Ollama
-<Note>Codex requires a larger context window. It is recommended to use a context window of at least 64k tokens.</Note>
+<Note>Use a context window of at least 64k tokens for Codex.</Note>
 ### Quick setup
@@ -21,12 +21,21 @@ npm install -g @openai/codex
 ollama launch codex
 ```
 When launched through `ollama launch codex`, Ollama refreshes the model catalog
 and uses a dedicated Codex profile for that session.
 To configure without launching:
 ```shell
 ollama launch codex --config
 ```
 To remove the Ollama launch profile and generated model catalog:
 ```shell
 ollama launch codex --restore
 ```
 ### Manual setup
 To use `codex` with Ollama, use the `--oss` flag:
@@ -49,25 +58,33 @@ codex --oss -m gpt-oss:120b-cloud
 ### Profile-based setup
-For a persistent configuration, add an Ollama provider and profiles to `~/.codex/config.toml`:
+For a persistent Codex CLI configuration, create `~/.codex/ollama-launch.config.toml`:
 ```toml
 [model_providers.ollama-launch]
 name = "Ollama"
 base_url = "http://localhost:11434/v1"
 [profiles.ollama-launch]
 model = "gpt-oss:120b"
 model_provider = "ollama-launch"
 model_catalog_json = "/Users/you/.codex/model.json"
-[profiles.ollama-cloud]
+[model_providers.ollama-launch]
-model = "gpt-oss:120b-cloud"
+name = "Ollama"
-model_provider = "ollama-launch"
+base_url = "http://localhost:11434/v1/"
 wire_api = "responses"
 ```
 Then run:
 ```
 codex --profile ollama-launch
-codex --profile ollama-cloud
+```
 ## Web search through local Ollama
 Codex web-search requests sent through the Ollama profile are executed by
 Ollama for both local and cloud models. Sign in with `ollama signin` to use the
 web-search service.
 To disable web search for a Codex session:
 ```shell
 codex --profile ollama-launch -c 'web_search="disabled"'
 ```
@@ -0,0 +1,50 @@
 ---
 title: DeepSeek Harness
 ---
 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) is an open-source coding agent.
 <Note>DeepSeek Harness is currently a developer preview. Its upstream configuration may change between releases.</Note>
 ## Setup
 ```shell
 ollama launch dsh
 ```
 Ollama installs `@deepseek-ai/dsh` if needed. To choose a model:
 ```shell
 ollama launch dsh --model qwen3.8
 ollama launch dsh --model deepseek-v4-flash:cloud
 ```
 To configure without starting:
 ```shell
 ollama launch dsh --config
 ```
 ## Web search
 Web search is enabled automatically. It requires Ollama cloud access and a model that supports tools. Run `ollama signin` if needed.
 ## Configuration
 Ollama stores its settings in `~/.ollama/launch/dsh/settings.yaml`. These settings load last and set the model, provider, and web search connection. Repeated launches preserve other settings in this file. Ollama does not change `~/.dsh/settings.yaml`, profiles, sessions, or credentials.
 Launch rejects additional `--patch` arguments. Pass other Harness arguments after `--`:
 ```shell
 ollama launch dsh -- --port 3081
 ```
 ## Manual install
 DeepSeek Harness requires Node.js. To install it manually:
 ```shell
 npm install -g @deepseek-ai/dsh@latest
 ```
 Then run `ollama launch dsh`. On Windows, install Node.js for Windows.
@@ -4,7 +4,7 @@ title: Goose
 ## Goose Desktop
-Install [Goose](https://block.github.io/goose/docs/getting-started/installation/) Desktop.
+Install [Goose](https://goose-docs.ai/docs/getting-started/installation/) Desktop.
 ### Usage with Ollama
 1. In Goose, open **Settings** → **Configure Provider**.  
@@ -27,7 +27,7 @@ Install [Goose](https://block.github.io/goose/docs/getting-started/installation/
 ## Goose CLI
-Install [Goose](https://block.github.io/goose/docs/getting-started/installation/) CLI
+Install [Goose](https://goose-docs.ai/docs/getting-started/installation/) CLI
 ### Usage with Ollama
 1. Run `goose configure`
@@ -0,0 +1,38 @@
 ---
 title: Hermes Desktop
 ---
 Hermes Desktop is a native AI assistant app by Nous Research. It provides a desktop chat interface for Hermes Agent, an AI agent that can work with models, run tools, manage projects, use memory and skills, and connect to messaging gateways.
 ![Hermes Desktop with Ollama](http://files.ollama.com/hermes-agent.png)
 ## Quick start
 ```bash
 ollama launch hermes-desktop
 ```
 Ollama handles the setup flow automatically:
 1. **Install** - If Hermes isn't installed, Ollama prompts to install the Hermes command-line agent. On first desktop launch, Hermes builds its packaged desktop app.
 2. **Model** - Pick a model from the selector
 3. **Configure** - Ollama configures Hermes Desktop to use your selected Ollama model
 4. **Launch** - Ollama opens Hermes Desktop
 ## Run directly with a model
 ```bash
 ollama launch hermes-desktop --model <model>
 ```
 Run `ollama launch hermes-desktop` again to switch models later.
 ## Install Hermes Desktop directly
 On macOS and Windows, the Hermes Desktop installer is the recommended upstream installation path. It installs the desktop app and Hermes Agent together. If you prefer the command line, `ollama launch hermes-desktop` remains the explicit Ollama-managed path and uses the same Hermes configuration, sessions, skills, and memory as the CLI.
 To force Hermes to rebuild its packaged desktop app:
 ```bash
 ollama launch hermes-desktop -- --force-build
 ```
@@ -14,13 +14,11 @@ ollama launch hermes
 Ollama handles everything automatically:
-1. **Install** — If Hermes isn't installed, Ollama prompts to install it via the Nous Research install script
+1. **Install** — If Hermes isn't installed, Ollama prompts to install the Hermes command-line agent
 2. **Model** — Pick a model from the selector (local or cloud)
 3. **Onboarding** — Ollama configures the Ollama provider, points Hermes at `http://127.0.0.1:11434/v1`, and sets your model as the primary
 4. **Gateway** — Optionally connects a messaging platform (Telegram, Discord, Slack, WhatsApp, Signal, Email) and launches the Hermes chat
 <Note>Hermes on Windows requires WSL2. Install it with `wsl --install` and re-run from inside the WSL shell.</Note>
 ## Recommended models
 **Cloud models**:
@@ -47,10 +45,10 @@ hermes gateway setup
 ## Reconfigure
-Re-run the full setup wizard at any time:
+Use Hermes's model picker to change providers or models later:
 ```bash
-hermes setup
+hermes model
 ```
 ## Manual setup
@@ -58,7 +56,7 @@ hermes setup
 If you'd rather drive Hermes's own wizard instead of `ollama launch hermes`, install it directly:
 ```bash
-curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
+curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
 ```
 Hermes launches the setup wizard automatically. Choose **Quick setup**:
@@ -108,7 +106,7 @@ Optionally connect a messaging platform during setup:
 Connect a messaging platform? (Telegram, Discord, etc.)
 →  Set up messaging now (recommended)
-    Skip — set up later with 'hermes setup gateway'
+    Skip — set up later with 'hermes gateway setup'
 ```
 ### Launch
@@ -116,4 +114,3 @@ Connect a messaging platform? (Telegram, Discord, etc.)
 ```
 Launch hermes chat now? [Y/n]: Y
 ```
@@ -2,53 +2,58 @@
 title: Overview
 ---
-Ollama integrates with a wide range of tools.
+Use Ollama models in your apps and tools.
-## Coding Agents
+## Launch a coding agent
-Coding assistants that can read, modify, and execute code in your projects.
+Run `ollama launch` in a terminal to choose a coding agent.
- [Claude Code](/integrations/claude-code)
+<CardGroup cols={2}>
- [Codex](/integrations/codex)
+  <Card title="Claude Code" icon="/images/launch-icons/claude-code.svg" href="/integrations/claude-code">
- [Copilot CLI](/integrations/copilot-cli)
+    Read code, edit files, and run commands.
- [OpenCode](/integrations/opencode)
+  </Card>
 - [Droid](/integrations/droid)
 - [Goose](/integrations/goose)
 - [Pi](/integrations/pi)
 - [Pool](/integrations/pool)
-## Assistants
+  <Card title="OpenCode" icon="/images/launch-icons/opencode.svg" href="/integrations/opencode">
    Edit and run code from your terminal.
  </Card>
-AI assistants that help with everyday tasks.
+  <Card title="DeepSeek Harness" icon="/images/launch-icons/deepseek-harness.svg" href="/integrations/deepseek-harness">
    Use DeepSeek's open-source coding agent in your browser.
  </Card>
 </CardGroup>
- [OpenClaw](/integrations/openclaw)
+## Connect a desktop app
 - [Hermes Agent](/integrations/hermes)
-## IDEs & Editors
+On macOS, open the [Ollama app](https://ollama.com/download) and select **Apps** in the sidebar. Connect Claude or ChatGPT.
-Native integrations for popular development environments.
+<CardGroup cols={2}>
  <Card title="Claude Desktop" icon="/images/launch-icons/claude.svg" href="/integrations/claude-desktop">
    Use local and cloud Ollama models.
  </Card>
- [VS Code](/integrations/vscode)
+  <Card title="ChatGPT Desktop" icon="/images/launch-icons/chatgpt.svg" href="/integrations/chatgpt">
- [Cline](/integrations/cline)
+    Use Ollama models in Codex mode.
- [Roo Code](/integrations/roo-code)
+  </Card>
- [JetBrains](/integrations/jetbrains)
+</CardGroup>
 - [Xcode](/integrations/xcode)
 - [Zed](/integrations/zed)
-## Chat & RAG
+## Run a personal assistant
-Chat interfaces and retrieval-augmented generation platforms.
+Run `ollama launch` in a terminal and choose OpenClaw or Hermes Agent.
- [Onyx](/integrations/onyx)
+<CardGroup cols={2}>
  <Card title="OpenClaw" icon="/images/launch-icons/openclaw.svg" href="/integrations/openclaw">
    Chat with an assistant through your messaging apps.
  </Card>
-## Automation
+  <Card title="Hermes Agent" icon="/images/launch-icons/hermes-agent.svg" href="/integrations/hermes">
    Personal assistant with memory, reusable skills, and messaging.
  </Card>
 </CardGroup>
-Workflow automation platforms with AI integration.
+## Work in your editor
- [n8n](/integrations/n8n)
+<CardGroup cols={2}>
-
+  <Card title="VS Code" icon="/images/launch-icons/vscode.svg" href="/integrations/vscode">
-## Notebooks
+    Install the Ollama extension to use models in VS Code Chat.
-
+  </Card>
-Interactive computing environments with AI capabilities.
+</CardGroup>
 - [marimo](/integrations/marimo)
@@ -0,0 +1,35 @@
 ---
 title: Oh My Pi
 ---
 Oh My Pi (OMP) is a terminal coding agent with IDE-style tools built in. It combines chat, project context, structured code edits, language server support, debugging tools, browser access, plugins, and subagents in one terminal workflow.
 Ollama can configure OMP to use Ollama as its model provider and launch an interactive session.
 ![Oh My Pi with Ollama](http://files.ollama.com/omp.png)
 ## Quick setup
 ```bash
 ollama launch omp
 ```
 This configures Ollama as a provider, sets up web search tools, and starts OMP.
 ### Run directly with a model
 ```shell
 ollama launch omp --model <model>
 ```
 ## Plugins
 OMP supports plugins for extra tools and capabilities. When launching OMP through Ollama, the Ollama web search plugin is managed automatically.
 ## Manual setup
 Install OMP from [omp.sh](https://omp.sh), then run:
 ```bash
 ollama launch omp --config
 ```
@@ -2,30 +2,144 @@
 title: OpenCode
 ---
-OpenCode is an open-source AI coding assistant that runs in your terminal.
+[OpenCode](https://opencode.ai) is an open-source coding agent that runs in your terminal, reads your project, edits files, and runs commands.
-## Install
+Ollama configures OpenCode to use local and cloud models.
-Install the [OpenCode CLI](https://opencode.ai):
+## Get started
-```bash
+Launch OpenCode with Ollama:
 curl -fsSL https://opencode.ai/install | bash
 ```
-<Note>OpenCode requires a larger context window. It is recommended to use a context window of at least 64k tokens. See [Context length](/context-length) for more information.</Note>
+```shell
 ## Usage with Ollama
 ### Quick setup
 ```bash
 ollama launch opencode
 ```
-To configure without launching:
+## Capabilities
 <div className="capability-list capability-list-full">
  <div className="capability-list-grid">
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="comment" /></div>
      <div>
        <div className="capability-list-heading">Chat</div>
        <div className="capability-list-copy">Ask questions about a repository or task</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="terminal" /></div>
      <div>
        <div className="capability-list-heading">Command line</div>
        <div className="capability-list-copy">Run commands from your working directory</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="code" /></div>
      <div>
        <div className="capability-list-heading">File edits</div>
        <div className="capability-list-copy">Read and edit files in your project</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="users" /></div>
      <div>
        <div className="capability-list-heading">Subagents</div>
        <div className="capability-list-copy">Split work across tasks</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="file-text" /></div>
      <div>
        <div className="capability-list-heading">Web fetch</div>
        <div className="capability-list-copy">Fetch and summarize web pages</div>
      </div>
    </div>
    <div className="capability-list-item">
      <div className="capability-list-icon"><Icon icon="image" /></div>
      <div>
        <div className="capability-list-heading">Vision</div>
        <div className="capability-list-copy">Send images and screenshots</div>
      </div>
    </div>
  </div>
 </div>
 ## Models
 Choose a model with enough context for your repository.
 <CardGroup cols={2}>
  <Card title="Cloud models" icon="cloud" href="https://ollama.com/search?c=cloud">
    Use larger models without downloading them.
  </Card>
  <Card title="Local models" icon="hard-drive" href="https://ollama.com/search?c=tools">
    Choose a model and set a 64k+ context window.
  </Card>
 </CardGroup>
 <Note>OpenCode requires a context length of 64k or higher. See [Context length](/context-length) for more information.</Note>
 ## Manual setup
 <p className="manual-step-title">1. Install OpenCode</p>
 <CodeGroup>
 ```shell macOS / Linux
 curl -fsSL https://opencode.ai/install | bash
 ```
 ```powershell Windows
 npm install -g opencode-ai
 ```
 </CodeGroup>
 <p className="manual-step-title">2. Configure Ollama as a provider</p>
 Add an Ollama provider to `opencode.json`:
 ```json
 {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen3.5": {
          "name": "qwen3.5"
        }
      }
    }
  }
 }
 ```
 <p className="manual-step-title">3. Run OpenCode</p>
 ```shell
 opencode
 ```
 To configure OpenCode with Ollama without starting an interactive session:
 ```shell
 ollama launch opencode --config
 ```
-<Note>`ollama launch opencode` passes its configuration to OpenCode inline via the `OPENCODE_CONFIG_CONTENT` environment variable. OpenCode deep-merges its config sources on startup, so anything you declare in `~/.config/opencode/opencode.json` is still respected and available inside OpenCode. Models declared only in `opencode.json` won't appear in `ollama launch`'s model-selection menu.</Note>
+### Configuration precedence
 `ollama launch opencode` starts OpenCode with an inline config for the selected Ollama model. It does not overwrite `~/.config/opencode/opencode.json`; existing OpenCode settings still apply.
 Models defined only in `opencode.json` do not appear in the `ollama launch` model picker.
 See OpenCode's [config precedence](https://opencode.ai/docs/config/#precedence-order).
@@ -4,23 +4,13 @@ title: Pi
 Pi is a minimal and extensible coding agent.
-## Install
+## Quick setup
 Install [Pi](https://github.com/badlogic/pi-mono):
 ```bash
 npm install -g @mariozechner/pi-coding-agent
 ```
 ## Usage with Ollama
 ### Quick setup
 ```bash
 ollama launch pi
 ```
-This installs Pi, configures Ollama as a provider including web tools, and drops you into an interactive session.
+This installs Pi if needed, configures Ollama as a provider including web tools, and drops you into an interactive session.
 To configure without launching:
@@ -80,6 +70,16 @@ Each kept experiment is automatically committed. Each failed one is reverted. Wh
 ## Manual setup
 ### Install
 Install [Pi](https://github.com/earendil-works/pi):
 ```bash
 npm install -g @earendil-works/pi-coding-agent
 ```
 Add a configuration block to `~/.pi/agent/models.json`:
 ```json
@@ -2,84 +2,57 @@
 title: VS Code
 ---
-VS Code includes built-in AI chat through GitHub Copilot Chat. Ollama models can be used directly in the Copilot Chat model picker.
+Use Ollama models in VS Code Chat with the [Ollama extension](https://marketplace.visualstudio.com/items?itemName=Ollama.ollama).
 ## Requirements
-![VS Code with Ollama](/images/vscode.png)
+- [Visual Studio Code 1.127 or newer](https://code.visualstudio.com/download)
 - Ollama installed and running
 - At least one local or cloud model available in Ollama
 Earlier VS Code versions do not reliably cancel requests from language model providers.
-## Prerequisites
+Ollama 0.17.6 or newer is recommended for cloud model sign-in and richer model metadata. Older versions may still work with local models.
- Ollama v0.18.3+
+## Install the extension
 - [VS Code 1.113+](https://code.visualstudio.com/download)
 - [GitHub Copilot Chat extension 0.41.0+](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot-chat)
-<Note> VS Code requires you to be logged in to use its model selector, even for custom models. This doesn't require a paid GitHub Copilot account; GitHub Copilot Free will enable model selection for custom models.</Note>
+1. Install the [Ollama extension](https://marketplace.visualstudio.com/items?itemName=Ollama.ollama) from the VS Code Marketplace.
 2. Open Chat in VS Code.
 3. Open the model picker at the bottom of the chat input.
 4. Choose a model from the **Ollama** section.
-## Quick setup
+The extension discovers models from `http://127.0.0.1:11434` by default.
 ## Add a model
 Pull a local model:
 ```shell
-ollama launch vscode
+ollama pull qwen3.6
 ```
-Recommended models will be shown after running the command. See the latest models at [ollama.com](https://ollama.com/search?c=tools).
+To use a cloud model, pull it and sign in:
 Make sure **Local** is selected at the bottom of the Copilot Chat panel to use your Ollama models.
 <div style={{ display: "flex", justifyContent: "center" }}>
  <img
    src="/images/local.png"
    alt="Ollama Local Models"
    width="60%"
    style={{ borderRadius: "4px", marginTop: "10px", marginBottom: "10px" }}
  />
 </div>
 ## Run directly with a model
 ```shell
-ollama launch vscode --model qwen3.5:cloud
+ollama pull kimi-k2.6:cloud
 ollama signin
 ```
 Cloud models are also available at [ollama.com](https://ollama.com/search?c=cloud).
-## Manual setup
+Local models do not require sign-in.
-To configure Ollama manually without `ollama launch`:
+## Context length
-1. Open the **Copilot Chat** side bar from the top right corner
+VS Code may show a model's maximum supported context length even when Ollama allocates a smaller context at runtime.
   <div style={{ display: "flex", justifyContent: "center" }}>
     <img
       src="/images/vscode-sidebar.png"
       alt="VS Code chat Sidebar"
       width="75%"
       style={{ borderRadius: "4px" }}
     />
   </div>
 2. Click the **settings gear icon** (<Icon icon="gear" />) to bring up the Language Models window
   <div style={{ display: "flex", justifyContent: "center" }}>
     <img
       src="/images/vscode-other-models.png"
       alt="VS Code model picker"
       width="75%"
       style={{ borderRadius: "4px" }}
     />
   </div>
 3. Click **Add Models** and select **Ollama** to load all your Ollama models into VS Code
   <div style={{ display: "flex", justifyContent: "center" }}>
     <img
       src="/images/vscode-add-ollama.png"
       alt="VS Code model options dropdown to add ollama models"
       width="75%"
       style={{ borderRadius: "4px" }}
     />
   </div>
-4. Click the **Unhide** button in the model picker to show your Ollama models  
+For local models, open Ollama **Settings**, set the context length to at least 64k, reload the VS Code window, and resend your prompt. See [Context length](/context-length) for more information.
-   <div style={{ display: "flex", justifyContent: "center" }}>
+
-     <img
+## Troubleshooting
-       src="/images/vscode-unhide.png"
+
-       alt="VS Code unhide models button"
+If Ollama models do not appear in the model picker:
-       width="75%"
+
-       style={{ borderRadius: "4px" }}
+1. Make sure Ollama is running.
-     />
+2. Run `ollama list` and confirm that models are available.
-   </div>
+3. Run **Ollama: Refresh Models** from the Command Palette.
 4. Run **Ollama: Diagnose Models** and check the **Ollama** output channel.
 If a cloud model asks you to sign in, run `ollama signin`.
@@ -116,7 +116,7 @@ sudo systemctl status ollama
  While AMD has contributed the `amdgpu` driver upstream to the official linux
  kernel source, the version is older and may not support all ROCm features. We
  recommend you install the latest driver from
-  https://www.amd.com/en/support/linux-drivers for best support of your Radeon
+  https://www.amd.com/en/support/download/linux-drivers.html for best support of your Radeon
  GPU.
 </Note>
@@ -12,15 +12,15 @@ A Modelfile is the blueprint to create and share customized models using Ollama.
  - [FROM (Required)](#from-required)
    - [Build from existing model](#build-from-existing-model)
    - [Build from a Safetensors model](#build-from-a-safetensors-model)
-    - [Build from a GGUF file](#build-from-a-gguf-file)
+    - [Build from a GGUF model](#build-from-a-gguf-model)
  - [PARAMETER](#parameter)
    - [Valid Parameters and Values](#valid-parameters-and-values)
  - [TEMPLATE](#template)
    - [Template Variables](#template-variables)
  - [SYSTEM](#system)
  - [ADAPTER](#adapter)
  - [LICENSE](#license)
  - [MESSAGE](#message)
  - [CAPABILITY](#capability)
 - [Notes](#notes)
 ## Format
@@ -38,10 +38,10 @@ INSTRUCTION arguments
 | [`PARAMETER`](#parameter)           | Sets the parameters for how Ollama will run the model.         |
 | [`TEMPLATE`](#template)             | The full prompt template to be sent to the model.              |
 | [`SYSTEM`](#system)                 | Specifies the system message that will be set in the template. |
 | [`ADAPTER`](#adapter)               | Defines the (Q)LoRA adapters to apply to the model.            |
 | [`LICENSE`](#license)               | Specifies the legal license.                                   |
 | [`MESSAGE`](#message)               | Specify message history.                                       |
 | [`REQUIRES`](#requires)             | Specify the minimum version of Ollama required by the model.   |
 | [`CAPABILITY`](#capability)         | Declare an additional model capability.                       |
 ## Examples
@@ -107,12 +107,8 @@ FROM <model name>:<tag>
 FROM llama3.2
 ```
-<Card title="Base Models" href="https://github.com/ollama/ollama#model-library">
+<Card title="Model library" href="https://ollama.com/library">
-  A list of available base models
+  Browse available models
 </Card>
 <Card title="Base Models" href="https://ollama.com/library">
  Additional models can be found at
 </Card>
 #### Build from a Safetensors model
@@ -123,14 +119,7 @@ FROM <model directory>
 The model directory should contain the Safetensors weights for a supported architecture.
-Currently supported model architectures:
+#### Build from a GGUF model
 - Llama (including Llama 2, Llama 3, Llama 3.1, and Llama 3.2)
 - Mistral (including Mistral 1, Mistral 2, and Mixtral)
 - Gemma (including Gemma 1 and Gemma 2)
 - Phi3
 #### Build from a GGUF file
 ```
 FROM ./ollama-model.gguf
@@ -138,6 +127,12 @@ FROM ./ollama-model.gguf
 The GGUF file location should be specified as an absolute path or relative to the `Modelfile` location.
 For a split GGUF model, keep the original split filenames and use a wildcard that matches every shard. Shards can also be listed with separate `FROM` instructions.
 ```
 FROM ./model-*.gguf
 ```
 ### PARAMETER
 The `PARAMETER` instruction defines a parameter that can be set when the model is run.
@@ -152,11 +147,12 @@ PARAMETER <parameter> <parametervalue>
 | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | -------------------- |
 | num_ctx        | Sets the size of the context window used to generate the next token. (Default: 2048)                                                                                                                                                                                                                                                                                            | int        | num_ctx 4096         |
 | repeat_last_n  | Sets how far back for the model to look back to prevent repetition. (Default: 64, 0 = disabled, -1 = num_ctx)                                                                                                                                                                                                                                                                   | int        | repeat_last_n 64     |
-| repeat_penalty | Sets how strongly to penalize repetitions. A higher value (e.g., 1.5) will penalize repetitions more strongly, while a lower value (e.g., 0.9) will be more lenient. (Default: 1.1)                                                                                                                                                                                             | float      | repeat_penalty 1.1   |
+| repeat_penalty | Sets how strongly to penalize repetitions. A higher value (e.g., 1.5) will penalize repetitions more strongly, while a lower value (e.g., 0.9) will be more lenient. (Default: 1.0, disabled)                                                                                                                                                                                   | float      | repeat_penalty 1.1   |
 | temperature    | The temperature of the model. Increasing the temperature will make the model answer more creatively. (Default: 0.8)                                                                                                                                                                                                                                                             | float      | temperature 0.7      |
 | seed           | Sets the random number seed to use for generation. Setting this to a specific number will make the model generate the same text for the same prompt. (Default: 0)                                                                                                                                                                                                               | int        | seed 42              |
 | stop           | Sets the stop sequences to use. When this pattern is encountered the LLM will stop generating text and return. Multiple stop patterns may be set by specifying multiple separate `stop` parameters in a modelfile.                                                                                                                                                              | string     | stop "AI assistant:" |
 | num_predict    | Maximum number of tokens to predict when generating text. (Default: -1, infinite generation)                                                                                                                                                                                                                                                                                    | int        | num_predict 42       |
 | draft_num_predict | Maximum number of speculative draft tokens to predict per step when a draft model is available. Separate draft models default to 4; embedded MTP tensors require setting this parameter. Set to 0 to disable speculative drafting.                                                                                                                                               | int        | draft_num_predict 4  |
 | top_k          | Reduces the probability of generating nonsense. A higher value (e.g. 100) will give more diverse answers, while a lower value (e.g. 10) will be more conservative. (Default: 40)                                                                                                                                                                                                | int        | top_k 40             |
 | top_p          | Works together with top-k. A higher value (e.g., 0.95) will lead to more diverse text, while a lower value (e.g., 0.5) will generate more focused and conservative text. (Default: 0.9)                                                                                                                                                                                         | float      | top_p 0.9            |
 | min_p          | Alternative to the top*p, and aims to ensure a balance of quality and variety. The parameter \_p* represents the minimum probability for a token to be considered, relative to the probability of the most likely token. For example, with _p_=0.05 and the most likely token having a probability of 0.9, logits with a value less than 0.045 are filtered out. (Default: 0.0) | float      | min_p 0.05           |
@@ -190,28 +186,6 @@ The `SYSTEM` instruction specifies the system message to be used in the template
 SYSTEM """<system message>"""
 ```
 ### ADAPTER
 The `ADAPTER` instruction specifies a fine tuned LoRA adapter that should apply to the base model. The value of the adapter should be an absolute path or a path relative to the Modelfile. The base model should be specified with a `FROM` instruction. If the base model is not the same as the base model that the adapter was tuned from the behaviour will be erratic.
 #### Safetensor adapter
 ```
 ADAPTER <path to safetensor adapter>
 ```
 Currently supported Safetensor adapters:
 - Llama (including Llama 2, Llama 3, and Llama 3.1)
 - Mistral (including Mistral 1, Mistral 2, and Mixtral)
 - Gemma (including Gemma 1 and Gemma 2)
 #### GGUF adapter
 ```
 ADAPTER ./ollama-lora.gguf
 ```
 ### LICENSE
 The `LICENSE` instruction allows you to specify the legal license under which the model used with this Modelfile is shared or distributed.
@@ -249,6 +223,14 @@ MESSAGE user Is Ontario in Canada?
 MESSAGE assistant yes
 ```
 ### CAPABILITY
 Adds a capability to a GGUF or MLX model without removing inherited or inferred capabilities. Repeat the instruction to add more than one. Declare `decision` only for weights trained for System One's decision prompts:
 ```
 CAPABILITY decision
 ```
 ### REQUIRES
 The `REQUIRES` instruction allows you to specify the minimum version of Ollama required by the model.
@@ -2,66 +2,300 @@
 title: Quickstart
 ---
-Ollama is available on macOS, Windows, and Linux.
+Use Ollama in [desktop apps](#connect-a-desktop-app) and [coding agents](#use-a-coding-agent), or [build an application](#build-an-application) with an API key.
-<a
+## Get started
  href="https://ollama.com/download"
  target="_blank"
  className="inline-block px-6 py-2 bg-black rounded-full dark:bg-neutral-700 text-white font-normal border-none"
 >
  Download Ollama
 </a>
-## Get Started
+[Download Ollama](https://ollama.com/download) for macOS, Windows, or Linux. Open the app, or get started from your terminal:
-Run `ollama` in your terminal to open the interactive menu:
+```shell
 ```sh
 ollama
 ```
-Navigate with `↑/↓`, press `enter` to launch, `→` to change model, and `esc` to quit.
+Follow the setup prompts. Sign in to use cloud models, or choose a local model.
-The menu provides quick access to:
+## Connect a desktop app
 - **Run a model** - Start an interactive chat
 - **Launch tools** - Claude Code, Codex, OpenClaw, and more
 - **Additional integrations** - Available under "More..."
-## Assistants
+On macOS, open Ollama and select **Apps**. Connect **Claude** or **ChatGPT (Desktop)**. Follow the prompts to install or restart the app.
-Launch [OpenClaw](/integrations/openclaw), a personal AI with 100+ skills:
+Choose your Ollama models in **Settings → Apps**.
-```sh
+- [Claude Desktop](/integrations/claude-desktop) — use Ollama models in Claude.
-ollama launch openclaw
+- [ChatGPT Desktop](/integrations/chatgpt) — use Ollama models in Codex mode. Regular Chat and voice use your usual ChatGPT connection.
 ```
-## Coding
+## Use a coding agent
-Launch [Claude Code](/integrations/claude-code) and other coding tools with Ollama models:
+From your project directory, launch your agent:
-```sh
+<Tabs>
  <Tab title="Claude Code">
 ```shell
 ollama launch claude
 ```
-```sh
+Ollama offers to install Claude Code if needed. See [Claude Code](/integrations/claude-code) for details.
  </Tab>
  <Tab title="Codex CLI">
 [Install Codex CLI](/integrations/codex#install) first, then launch it:
 ```shell
 ollama launch codex
 ```
-```sh
+See [Codex CLI](/integrations/codex) for setup.
  </Tab>
  <Tab title="OpenCode">
 ```shell
 ollama launch opencode
 ```
-See [integrations](/integrations) for all supported tools.
+Ollama offers to install OpenCode if needed. See [OpenCode](/integrations/opencode) for details.
-## API
+  </Tab>
 </Tabs>
-Use the [API](/api) to integrate Ollama into your applications:
+Choose a model when prompted, then try:
-```sh
+```text
-curl http://localhost:11434/api/chat -d '{
+Explain how this repository is organized.
  "model": "gemma3",
  "messages": [{ "role": "user", "content": "Hello!" }]
 }'
 ```
-See the [API documentation](/api) for Python, JavaScript, and other integrations.
+For more tools, see [Integrations](/integrations). To connect an agent directly with an API key, see [Claude Code](/integrations/claude-code#connect-directly-to-ollama-cloud).
 ## Build an application
 Use cloud models with an API key, or run models locally without one. Cloud requests do not require an Ollama installation.
 ### 1. Create an API key
 For local models, skip this step and select **Local** under [Send a request](#2-send-a-request).
 For cloud models, sign in or create an account, then create an [API key](https://ollama.com/settings/keys).
 Set your key in the terminal:
 <CodeGroup>
 ```shell macOS / Linux
 export OLLAMA_API_KEY="your_api_key"
 ```
 ```powershell Windows
 $env:OLLAMA_API_KEY = "your_api_key"
 ```
 </CodeGroup>
 Keep your key on your application's server, outside browser code and source control.
 ### 2. Send a request
 Make your first request to Ollama
 <Tabs>
  <Tab title="Cloud">
 These examples use the `gemma4:31b` [cloud model](https://ollama.com/search?c=cloud).
 <Tabs>
  <Tab title="Ollama API">
 ```shell
 curl https://ollama.com/api/chat \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:31b",
    "messages": [
      {
        "role": "user",
        "content": "Say hello in one sentence."
      }
    ],
    "stream": false
  }'
 ```
 Read the answer from `message.content`. See [Ollama's API and libraries](/api/introduction).
  </Tab>
  <Tab title="OpenAI Chat Completions">
 ```shell
 curl https://ollama.com/v1/chat/completions \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:31b",
    "messages": [
      {
        "role": "user",
        "content": "Say hello in one sentence."
      }
    ]
  }'
 ```
 Read the answer from `choices[0].message.content`. See [OpenAI compatibility](/api/openai-compatibility) for client setup and supported features.
  </Tab>
  <Tab title="OpenAI Responses">
 ```shell
 curl https://ollama.com/v1/responses \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:31b",
    "input": "Say hello in one sentence."
  }'
 ```
 Read the `output_text` content blocks inside `output`. The OpenAI Python client exposes the text as `response.output_text`.
 Responses requests are stateless: include conversation history in each request. `previous_response_id` and `conversation` aren't supported. See [Responses compatibility](/api/openai-compatibility#responses-api).
  </Tab>
  <Tab title="Anthropic Messages">
 ```shell
 curl https://ollama.com/v1/messages \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "gemma4:31b",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Say hello in one sentence."
      }
    ]
  }'
 ```
 Read text blocks from `content`. Direct cloud requests use bearer authentication. See [Anthropic compatibility](/api/anthropic-compatibility) for client setup and supported features.
  </Tab>
 </Tabs>
 OpenAI and Anthropic compatibility each cover a subset of the original API. See [Cloud](/cloud) for models and usage limits.
  </Tab>
  <Tab title="Local">
 Run [Gemma 4 E2B](https://ollama.com/library/gemma4:e2b) on your computer. No API key required.
 <Note>
 The model download is about 7.2 GB. We recommend 8 GB of available VRAM, or unified memory on a Mac. Larger context windows need more memory. With less VRAM, Ollama can use system RAM, but responses may be slower.
 </Note>
 [Download Ollama](https://ollama.com/download) and open the app. On Linux, start the server with `ollama serve` if it is not already running.
 Download the model:
 ```shell
 ollama pull gemma4:e2b
 ```
 Send a request to your local server:
 <Tabs>
  <Tab title="Ollama API">
 ```shell
 curl http://localhost:11434/api/chat \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:e2b",
    "messages": [
      {
        "role": "user",
        "content": "Say hello in one sentence."
      }
    ],
    "stream": false
  }'
 ```
  </Tab>
  <Tab title="OpenAI Chat Completions">
 ```shell
 curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:e2b",
    "messages": [
      {
        "role": "user",
        "content": "Say hello in one sentence."
      }
    ]
  }'
 ```
 Read the answer from `choices[0].message.content`. See [OpenAI compatibility](/api/openai-compatibility) for client setup and supported features.
  </Tab>
  <Tab title="OpenAI Responses">
 ```shell
 curl http://localhost:11434/v1/responses \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:e2b",
    "input": "Say hello in one sentence."
  }'
 ```
 Read the `output_text` content blocks inside `output`. The OpenAI Python client exposes the text as `response.output_text`.
 Responses requests are stateless: include conversation history in each request. `previous_response_id` and `conversation` aren't supported. See [Responses compatibility](/api/openai-compatibility#responses-api).
  </Tab>
  <Tab title="Anthropic Messages">
 ```shell
 curl http://localhost:11434/v1/messages \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "gemma4:e2b",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Say hello in one sentence."
      }
    ]
  }'
 ```
 Read text blocks from `content`. See [Anthropic compatibility](/api/anthropic-compatibility) for client setup and supported features.
  </Tab>
 </Tabs>
  </Tab>
 </Tabs>
 ## Run a model locally
 [Download Ollama](https://ollama.com/download), then run:
 ```shell
 ollama run gemma4:e2b
 ```
 Ollama downloads the model and starts a chat on your computer. Type `/bye` to leave.
 ## Next steps
 Add [tool calling](/capabilities/tool-calling), [stream responses](/capabilities/streaming), or browse [more models](https://ollama.com/search).
@@ -14,3 +14,117 @@ pre, code, .font-mono {
    color: #666;
    font-weight: 400;
 }
 .capability-list {
    border-top: 1px solid #e5e5e5;
    border-bottom: 1px solid #e5e5e5;
    display: grid;
    gap: 2rem;
    grid-template-columns: 7rem minmax(0, 1fr);
    margin: 1.5rem 0 2rem;
    padding: 2rem 0;
 }
 .capability-list-title {
    color: #171717;
    font-size: 1rem;
    line-height: 1.5rem;
 }
 .capability-list-full {
    grid-template-columns: 1fr;
 }
 .capability-list-grid {
    display: grid;
    gap: 1.75rem 2rem;
    grid-template-columns: repeat(2, minmax(0, 1fr));
    min-width: 0;
 }
 .capability-list-item {
    align-items: flex-start;
    display: grid;
    gap: 0.75rem;
    grid-template-columns: 2rem minmax(0, 1fr);
    min-width: 0;
 }
 .capability-list-icon {
    align-items: center;
    background: #f1f1f1;
    border-radius: 0.75rem;
    color: #171717;
    display: flex;
    height: 2rem;
    justify-content: center;
    width: 2rem;
 }
 .capability-list-icon svg {
    height: 1rem;
    width: 1rem;
 }
 .capability-list-heading {
    color: #171717;
    font-size: 1rem;
    font-weight: 600;
    line-height: 1.375rem;
 }
 .capability-list-copy {
    color: #737373;
    font-size: 0.95rem;
    line-height: 1.375rem;
 }
 .manual-step-title {
    color: #171717;
    font-size: 0.95rem;
    font-weight: 600;
    line-height: 1.375rem;
    margin: 1.25rem 0 0.75rem;
 }
 .dark .capability-list {
    border-color: #262626;
 }
 .dark .capability-list-title,
 .dark .capability-list-heading,
 .dark .manual-step-title {
    color: #fafafa;
 }
 .dark .capability-list-icon {
    background: #262626;
    color: #fafafa;
 }
 .dark .capability-list-copy {
    color: #a3a3a3;
 }
@media (max-width: 920px) {
    .capability-list {
        grid-template-columns: 1fr;
    }
    .capability-list-grid {
        grid-template-columns: 1fr;
    }
 }
 .accordion-group {
    border-style: none;
    border-radius: 0;
 }
 .accordion-group div[id*="-accordion-children"] {
    margin-inline: calc(var(--spacing) * 1);
 }
 .accordion-group details summary {
    padding-inline: 0;
 }
@@ -137,7 +137,7 @@ After upgrading, reboot and restart Ollama.
 If you experience gibberish responses when models load across multiple AMD GPUs on Linux, see the following guide.
- https://rocm.docs.amd.com/projects/radeon/en/latest/docs/install/native_linux/mgpu.html#mgpu-known-issues-and-limitations
+- https://rocm.docs.amd.com/projects/radeon-ryzen/en/latest/docs/install/installrad/native_linux/mgpu.html#mgpu-known-issues-and-limitations
 ## Windows Terminal Errors
@@ -11,11 +11,19 @@ terminal application. As usual the Ollama [API](/api) will be served on
 ## System Requirements
 - Windows 10 22H2 or newer, Home or Pro
- NVIDIA 452.39 or newer Drivers if you have an NVIDIA card
+- NVIDIA 551.61 or newer Drivers if you have an NVIDIA card
- AMD Radeon Driver https://www.amd.com/en/support if you have a Radeon card
+- AMD ROCm v7 / HIP7-capable driver stack for ROCm acceleration, or a Vulkan-capable AMD Radeon driver for Vulkan acceleration
 Ollama uses unicode characters for progress indication, which may render as unknown squares in some older terminal fonts in Windows 10. If you see this, try changing your terminal font settings.
 <Note>
  Some RDNA2 / Radeon RX 6000 systems, including RX 6800-class cards, may not
  expose ROCm v7 on current Windows AMD drivers. Vulkan is enabled by default
  and is the recommended fallback for those systems. If a mixed iGPU/dGPU
  system selects an unstable Vulkan iGPU, set `GGML_VK_VISIBLE_DEVICES` to the
  discrete GPU index.
 </Note>
 ## Filesystem Requirements
 The Ollama install does not require Administrator, and installs in your home directory by default. You'll need at least 4GB of space for the binary install. Once you've installed Ollama, you'll need additional space for storing the Large Language models, which can be tens to hundreds of GB in size. If your home directory doesn't have enough space, you can change where the binaries are installed, and where the models are stored.
Author	SHA1	Message	Date
The Librarian	a8b97b807a	Sync ollama docs from eab97e9f on 2026-10-12	2026-10-12 04:00:05 +00:00
The Librarian	f10d4bfbcc	Sync ollama docs from 53fed261 on 2026-09-12	2026-09-12 04:00:05 +00:00
The Librarian	1f556d946e	Sync ollama docs from 948f6933 on 2026-08-12	2026-08-12 04:00:08 +00:00
The Librarian	6d510760b7	Sync ollama docs from 82f905cd on 2026-07-12	2026-07-12 04:00:08 +00:00
The Librarian	70feb5e845	Sync ollama docs from 12e04379 on 2026-06-12	2026-06-12 04:00:06 +00:00
`@@ -11,4 +11,4 @@ Ollama JavaScript examples at [ollama-js/examples](https://github.com/ollama/oll`


	`## OpenAI compatibility examples`	`## OpenAI compatibility examples`
	`Ollama OpenAI compatibility examples at [ollama/examples/openai](../docs/openai.md)`	`Ollama OpenAI compatibility examples at [ollama/examples/openai](./api/openai-compatibility.mdx)`
		`@@ -0,0 +1 @@`
							`<svg height="24" style="flex:none;line-height:1" viewBox="-1 -1 26 26" width="24" xmlns="http://www.w3.org/2000/svg"><title>Claude Code</title><path clip-rule="evenodd" d="M20.998 10.949H24v3.102h-3v3.028h-1.487V20H18v-2.921h-1.487V20H15v-2.921H9V20H7.488v-2.921H6V20H4.487v-2.921H3V14.05H0V10.95h3V5h17.998v5.949zM6 10.949h1.488V8.102H6v2.847zm10.51 0H18V8.102h-1.49v2.847z" fill="#D97757" fill-rule="evenodd"></path></svg>`
		`@@ -0,0 +1 @@`
							<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 160 160"><rect width="160" height="160" rx="24" fill="#f7f7f7"/><g transform="translate(16 16)"><mask id="a" width="128" height="128" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#fff" fill-rule="evenodd" d="M90.767 127.126a7.968 7.968 0 0 0 6.35-.244l26.353-12.681a8 8 0 0 0 4.53-7.209V21.009a8 8 0 0 0-4.53-7.21L97.117 1.12a7.97 7.97 0 0 0-9.093 1.548l-50.45 46.026L15.6 32.013a5.328 5.328 0 0 0-6.807.302l-7.048 6.411a5.335 5.335 0 0 0-.006 7.888L20.796 64 1.74 81.387a5.336 5.336 0 0 0 .006 7.887l7.048 6.411a5.327 5.327 0 0 0 6.807.303l21.974-16.68 50.45 46.025a7.96 7.96 0 0 0 2.743 1.793Zm5.252-92.183L57.74 64l38.28 29.058V34.943Z" clip-rule="evenodd"/></mask><g mask="url(#a)"><path fill="#0065A9" d="M123.471 13.82 97.097 1.12A7.973 7.973 0 0 0 88 2.668L1.662 81.387a5.333 5.333 0 0 0 .006 7.887l7.052 6.411a5.333 5.333 0 0 0 6.811.303l103.971-78.875c3.488-2.646 8.498-.158 8.498 4.22v-.306a8.001 8.001 0 0 0-4.529-7.208Z"/><g filter="url(#b)"><path fill="#007ACC" d="m123.471 114.181-26.374 12.698A7.973 7.973 0 0 1 88 125.333L1.662 46.613a5.333 5.333 0 0 1 .006-7.887l7.052-6.411a5.333 5.333 0 0 1 6.811-.303l103.971 78.874c3.488 2.647 8.498.159 8.498-4.219v.306a8.001 8.001 0 0 1-4.529 7.208Z"/></g><g filter="url(#c)"><path fill="#1F9CF0" d="M97.098 126.882A7.977 7.977 0 0 1 88 125.333c2.952 2.952 8 .861 8-3.314V5.98c0-4.175-5.048-6.266-8-3.313a7.977 7.977 0 0 1 9.098-1.549L123.467 13.8A8 8 0 0 1 128 21.01v85.982a8 8 0 0 1-4.533 7.21l-26.369 12.681Z"/></g><path fill="url(#d)" fill-rule="evenodd" d="M90.69 127.126a7.968 7.968 0 0 0 6.349-.244l26.353-12.681a8 8 0 0 0 4.53-7.21V21.009a8 8 0 0 0-4.53-7.21L97.039 1.12a7.97 7.97 0 0 0-9.093 1.548l-50.45 46.026-21.974-16.68a5.328 5.328 0 0 0-6.807.302l-7.048 6.411a5.336 5.336 0 0 0-.006 7.888L20.718 64 1.662 81.386a5.335 5.335 0 0 0 .006 7.888l7.048 6.411a5.328 5.328 0 0 0 6.807.303l21.975-16.681 50.45 46.026a7.959 7.959 0 0 0 2.742 1.793Zm5.252-92.184L57.662 64l38.28 29.057V34.943Z" clip-rule="evenodd" opacity="0.25" style="mix-blend-mode:overlay"/></g><defs><filter id="b" width="144.744" height="113.408" x="-8.41115" y="22.5944" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feColorMatrix in="SourceAlpha" result="hardAlpha" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"/><feOffset/><feGaussianBlur stdDeviation="4.16667"/><feColorMatrix values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/><feBlend in2="BackgroundImageFix" mode="overlay" result="effect1_dropShadow_1_36"/><feBlend in="SourceGraphic" in2="effect1_dropShadow_1_36" result="shape"/></filter><filter id="c" width="56.6667" height="144.007" x="79.6667" y="-8.0035" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feColorMatrix in="SourceAlpha" result="hardAlpha" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"/><feOffset/><feGaussianBlur stdDeviation="4.16667"/><feColorMatrix values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.25 0"/><feBlend in2="BackgroundImageFix" mode="overlay" result="effect1_dropShadow_1_36"/><feBlend in="SourceGraphic" in2="effect1_dropShadow_1_36" result="shape"/></filter><linearGradient id="d" x1="63.9222" x2="63.9222" y1="0.329902" y2="127.67" gradientUnits="userSpaceOnUse"><stop stop-color="#fff"/><stop offset="1" stop-color="#fff" stop-opacity="0"/></linearGradient></defs></g></svg>