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 · 2026-05-12 04:00:09 +00:00
76 changed files with 3989 additions and 1356 deletions
@@ -4,8 +4,8 @@ This is a mirror of the Ollama repository.

 **Synced from:** https://github.com/ollama/ollama.git
 **Branch:** main
-**Commit:** f8dc7c9f54a753d2c6d3410936e73486f9bf463d
-**Sync Date:** 2026-02-12
+**Commit:** eab97e9f92b9a25c2d52d2cc6c1b1c99bd9fae21
+**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 |
-| ------ | :---------: |
-| q4_K_M |     \*      |
-| q4_K_S |             |
-| q8_0   |     \*      |
+| Type  | Recommended |
+| ----- | :---------: |
+| nvfp4 |     \*      |
+| mxfp8 |     \*      |
+| 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":"creating new layer sha256:05ca5b813af4a53d2c2922933936e398958855c44ee534858fcfd830940618b6"}
-{"status":"using autodetected template llama3-instruct"}
-{"status":"using existing layer sha256:56bb8bd477a519ffa694fc449c2413c6f0e1d3b1c88fa7e3c9d88d3ae49d4dcb"}
-{"status":"writing manifest"}
+{"status":"importing fred (2 tensors)"}
+{"status":"writing manifest for fred"}
 {"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

@@ -12,7 +45,6 @@ To use Ollama with tools that expect the Anthropic API (like Claude Code), set t

 ```shell
 export ANTHROPIC_AUTH_TOKEN=ollama  # required but ignored
-export ANTHROPIC_API_KEY="" # required but ignored
 export ANTHROPIC_BASE_URL=http://localhost:11434
 ```

@@ -235,56 +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. 
-
-### 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 ANTHROPIC_API_KEY="" 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
-export ANTHROPIC_API_KEY=""
-```
-
-Then run Claude Code with any Ollama model:
-
-```shell
-claude --model qwen3-coder
-```
+See the [Claude Code guide](/integrations/claude-code) for Ollama Launch and [direct cloud setup](/integrations/claude-code#connect-directly-to-ollama-cloud).

 ## Endpoints

@@ -320,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`

@@ -344,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.
@@ -362,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
- `minimax-m2.1:cloud` - Fast cloud model
-
-### Default model names
+### Default model names on a local server

 For tooling that relies on default Anthropic model names such as `claude-3-5-sonnet`, use `ollama cp` to copy an existing model name:

@@ -396,8 +380,8 @@ curl http://localhost:11434/v1/messages \

 ### Behavior differences

- API key is accepted but not validated
- `anthropic-version` header is accepted but not used
+- The local server does not validate API keys. Direct cloud inference requires a valid bearer token.
+- 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
-* Publishing models
-* Downloading private models
+## API keys

-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
-* **API keys**: API keys for programmatic access to ollama.com's API
+Create an [API key](https://ollama.com/settings/keys), then set it in your terminal:
+
+```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":"gemma3","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":"gemma3","created_at":"2025-10-26T17:21:21.231094Z","response":"can","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:21:21.196249Z","response":" Yes","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:21:21.207235Z","response":".","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:21:21.219166Z","response":"I","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

-```
-http://localhost:11434/api
-```
+| API | Direct cloud access | Local Ollama server |
+| --- | --- | --- |
+| 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.

-```
-https://ollama.com/api
-```
+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).

-## 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 '{
-  "model": "gemma3",
-  "prompt": "Why is the sky blue?"
-}'
+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
+  }'
 ```

+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,11 +2,45 @@
 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

-### Simple `v1/chat/completions` example
+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

 <CodeGroup dropdown>

@@ -57,7 +91,7 @@ curl -X POST http://localhost:11434/v1/chat/completions \

 </CodeGroup>

-### Simple `v1/responses` example
+### Simple `/v1/responses` example

 <CodeGroup dropdown>

@@ -103,7 +137,7 @@ curl -X POST http://localhost:11434/v1/responses \

 </CodeGroup>

-### v1/chat/completions with vision example
+### `/v1/chat/completions` with vision example

 <CodeGroup dropdown>

@@ -184,6 +218,7 @@ curl -X POST http://localhost:11434/v1/chat/completions \
 - [x] Reproducible outputs
 - [x] Vision
 - [x] Tools
+- [x] Reasoning/thinking control (for thinking models)
 - [ ] Logprobs

 #### Supported request fields
@@ -207,11 +242,16 @@ curl -X POST http://localhost:11434/v1/chat/completions \
 - [x] `top_p`
 - [x] `max_tokens`
 - [x] `tools`
+- [x] `reasoning_effort` (model-defined names and compatibility aliases)
+- [x] `reasoning`
+  - [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
@@ -275,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.
-
-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`
+`POST /v1/responses`

 > Note: Added in Ollama v0.13.3

@@ -365,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:

@@ -401,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":"gemma3","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":"gemma3","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":"gemma3","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.097767Z","response":"That","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.109172Z","response":"'","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.121485Z","response":"s","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.132802Z","response":" a","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.143931Z","response":" fantastic","done":false}
+{"model":"gemma4","created_at":"2025-10-26T17:15:24.155176Z","response":" question","done":false}
+{"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_duration`: How long it took to evaluate the prompt
+* `prompt_eval_count`: How many input tokens were in 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.
@@ -2,6 +2,10 @@
 title: Structured Outputs
 ---

+<Note>
+  Ollama's Cloud currently does not support structured outputs.
+</Note>
+
 Structured outputs let you enforce a JSON schema on model responses so you can reliably extract structured data, describe images, or keep every reply consistent.

 ## Generating structured JSON
@@ -96,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 { zodToJsonSchema } from 'zod-to-json-schema'
+    import * as z from 'zod'

    const Country = z.object({
      name: z.string(),
@@ -112,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))
@@ -173,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)
- [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)
- [DeepSeek R1](https://ollama.com/library/deepseek-r1)
- Browse the latest additions under [thinking models](https://ollama.com/search?c=thinking)
+## Discover a model's thinking controls
+
+Thinking controls vary by model. Use `/api/show` to discover the values a model supports and the value Ollama uses by default:
+
+```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
@@ -21,6 +21,7 @@ Configure and launch external applications to use Ollama models. This provides a
 - **OpenCode** - Open-source coding assistant
 - **Claude Code** - Anthropic's agentic coding tool
 - **Codex** - OpenAI's coding assistant
+- **VS Code** - Microsoft's IDE with built-in AI chat
 - **Droid** - Factory's AI coding agent

 #### Examples
@@ -40,7 +41,7 @@ ollama launch claude
 Launch with a specific model:

 ```
-ollama launch claude --model qwen3-coder
+ollama launch claude --model qwen3.5
 ```

 Configure without launching:
@@ -63,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
@@ -81,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
@@ -113,7 +114,7 @@ ollama signout
 First, create a `Modelfile`

 ```
-FROM gemma3
+FROM gemma4
 SYSTEM """You are a happy cat."""
 ```

@@ -132,7 +133,7 @@ ollama ps
 ### Stop a running model

 ```
-ollama stop gemma3
+ollama stop gemma4
 ```

 ### Start Ollama
@@ -3,226 +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).
-
-### 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
+```shell
+export OLLAMA_API_KEY="your_api_key"
 ```

-<Tabs>
-  <Tab title="CLI">
+Send a request from the same terminal:

-To run a cloud model, open the terminal and run:
-
-```
-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:
-
-```
+```shell
 curl https://ollama.com/api/chat \
  -H "Authorization: Bearer $OLLAMA_API_KEY" \
+  -H "Content-Type: application/json" \
  -d '{
-    "model": "gpt-oss:120b",
-    "messages": [{
-      "role": "user",
-      "content": "Why is the sky blue?"
-    }],
+    "model": "gemma4:31b",
+    "messages": [
+      {
+        "role": "user",
+        "content": "Say hello in one sentence."
+      }
+    ],
    "stream": false
  }'
 ```

-  </Tab>
-</Tabs>
+Read the answer from `message.content`. Keep your API key out of browser code and source control.
+
+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 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,50 +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)
-
-Install prerequisites:
-
- [CMake](https://cmake.org/download/) or `brew install cmake`
-
-Then, configure and build the project:
+MLX Metal requires the Metal toolchain. Install [Xcode](https://developer.apple.com/xcode/) first, then:

 ```shell
-cmake -B build
-cmake --build build
-```
-
-Lastly, run Ollama:
-
-```shell
-go run . serve
+xcodebuild -downloadComponent MetalToolchain
 ```

 ## 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)
- (Optional) VULKAN GPU support
-    - [VULKAN SDK](https://vulkan.lunarg.com/sdk/home) - useful for AMD/Intel GPUs
+    - [CUDA SDK](https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_type=exe_network)
+- (Optional) Vulkan GPU support
+    - [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:
-
-```shell
-cmake -B build
-cmake --build build --config Release
-```
+For Ninja builds, run CMake from a Developer PowerShell/Command Prompt or another shell where the Visual Studio compiler is available.

 > Building for Vulkan requires VULKAN_SDK environment variable:
 > 
@@ -70,52 +95,64 @@ 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
-    - [VULKAN SDK](https://vulkan.lunarg.com/sdk/home) - useful for AMD/Intel GPUs
+- (Optional) Vulkan GPU support
+    - [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)
+    - [cuDNN 9+](https://developer.nvidia.com/cudnn)
+    - OpenBLAS/LAPACK: `sudo apt install libopenblas-dev liblapack-dev liblapacke-dev` (Ubuntu/Debian)
 > [!IMPORTANT]
 > Ensure prerequisites are in `PATH` before running CMake.

+## MLX Engine (Optional)

-Then, configure and build the project:
+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`.
+
+### CUDA
+
+Requires CUDA 13+ and [cuDNN](https://developer.nvidia.com/cudnn) 9+.

 ```shell
-cmake -B build
-cmake --build build
+cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13
+cmake --build build --parallel 8
 ```

-Lastly, run Ollama:
+### Local MLX source overrides
+
+To build against a local checkout of MLX and/or MLX-C (useful for development), set environment variables before running CMake:

 ```shell
-go run . serve
+export OLLAMA_MLX_SOURCE=/path/to/mlx
+export OLLAMA_MLX_C_SOURCE=/path/to/mlx-c
+```
+
+On macOS arm64:
+
+```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"
+cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13
+cmake --build build --parallel 8
 ```

 ## Docker
@@ -138,42 +175,13 @@ To run tests, use `go test`:
 go test ./...
 ```

-> NOTE: In rare circumstances, you may need to change a package using the new
-> "synctest" package in go1.24.
->
-> If you do not have the "synctest" package enabled, you will not see build or
-> test failures resulting from your change(s), if any, locally, but CI will
-> break.
->
-> If you see failures in CI, you can either keep pushing changes to see if the
-> CI build passes, or you can enable the "synctest" package locally to see the
-> failures before pushing.
->
-> To enable the "synctest" package for testing, run the following command:
->
-> ```shell
-> GOEXPERIMENT=synctest go test ./...
-> ```
->
-> If you wish to enable synctest for all go commands, you can set the
-> `GOEXPERIMENT` environment variable in your shell profile or by using:
->
-> ```shell
-> go env -w GOEXPERIMENT=synctest
-> ```
->
-> Which will enable the "synctest" package for all go commands without needing
-> to set it for all shell sessions.
->
-> The synctest package is not required for production builds.
-
 ## 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` (Linux)
-* `.` (macOS)
-* `build/lib/ollama` (for development)
+* `../lib/ollama` for standard installs where `ollama` is under `bin/`
+* `./lib/ollama` for Windows release-style payloads and local dist output
+* `.` for macOS release artifacts that colocate helpers with `ollama`
+* `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"
@@ -75,12 +95,24 @@
    {
      "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"
    }
  ],
  "navigation": {
    "tabs": [
      {
-        "tab": "Documentation",
+        "tab": "Guide",
        "groups": [
          {
            "group": "Get started",
@@ -96,63 +128,13 @@
              "/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": "Coding",
-                "pages": [
-                  "/integrations/claude-code",
-                  "/integrations/codex",
-                  "/integrations/opencode",
-                  "/integrations/droid",
-                  "/integrations/goose"
-                ]
-              },
-              {
-                "group": "Assistants",
-                "pages": [
-                  "/integrations/openclaw"
-                ]
-              },
-              {
-                "group": "IDEs & Editors",
-                "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": [
@@ -171,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",
@@ -193,6 +250,7 @@
              "POST /api/generate",
              "POST /api/chat",
              "POST /api/embed",
+              "POST /v1/systemone",
              "GET /api/tags",
              "GET /api/ps",
              "POST /api/show",
@@ -201,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,6 +160,26 @@ 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 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. 
+
+Set `disable_ollama_cloud` in `~/.ollama/server.json`:
+
+```json
+{
+  "disable_ollama_cloud": true
+}
+```
+
+You can also set the environment variable:
+
+```shell
+OLLAMA_NO_CLOUD=1
+```
+
+Restart Ollama after changing configuration. Once disabled, Ollama's logs will show `Ollama cloud disabled: true`. 
+
 ## How can I expose Ollama on my network?

 Ollama binds 127.0.0.1 port 11434 by default. Change the bind address with the `OLLAMA_HOST` environment variable.
@@ -228,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?

@@ -323,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

@@ -61,20 +62,26 @@ Ollama supports the following AMD GPUs via the ROCm library:

 ### Linux Support

-| 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` `Vega 64`                  |
-| AMD Radeon PRO | `W7900` `W7800` `W7700` `W7600` `W7500` `W6900X` `W6800X Duo` `W6800X` `W6800` `V620` `V420` `V340` `V320` `Vega II Duo` `Vega II` `SSG`       |
-| AMD Instinct   | `MI300X` `MI300A` `MI300` `MI250X` `MI250` `MI210` `MI200` `MI100` `MI60`                                                                      |
+Ollama requires the AMD ROCm v7 driver on Linux. You can install or upgrade
+using the `amdgpu-install` utility from
+[AMD's ROCm documentation](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/).
+
+| 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` |
+| 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` |
+| AMD Instinct   | `MI350X` `MI300X` `MI300A` `MI250X` `MI250` `MI210` `MI100`                                                                                                   |

 ### 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 PRO | `W7900` `W7800` `W7700` `W7600` `W7500` `W6900X` `W6800X Duo` `W6800X` `W6800` `V620`                                |
+| AMD Radeon RX  | `7900 XTX` `7900 XT` `7900 GRE` `7800 XT` `7700 XT` `7600 XT` `7600`  |
+| AMD Radeon PRO | `W7900` `W7800` `W7700` `W7600` `W7500`                                |

 ### Overrides on Linux

@@ -97,17 +104,17 @@ This table shows some example GPUs that map to these LLVM targets:
 | **LLVM Target** | **An Example GPU** |
 |-----------------|---------------------|
 | gfx908 | Radeon Instinct MI100 |
-| gfx90a | Radeon Instinct MI210 |
-| gfx940 | Radeon Instinct MI300 |
-| gfx941 | |
-| gfx942 | |
+| gfx90a | Radeon Instinct MI210/MI250 |
+| gfx942 | Radeon Instinct MI300X/MI300A |
+| gfx950 | Radeon Instinct MI350X |
 | gfx1030 | Radeon PRO V620 |
 | gfx1100 | Radeon PRO W7900 |
 | gfx1101 | Radeon PRO W7700 |
 | gfx1102 | Radeon RX 7600 |
-
-AMD is working on enhancing ROCm v6 to broaden support for families of GPUs in a
-future release which should increase support for more GPUs.
+| gfx1150 | Ryzen AI 9 HX 375 |
+| gfx1151 | Ryzen AI Max+ 395 |
+| gfx1200 | Radeon RX 9070 |
+| gfx1201 | Radeon RX 9070 XT |

 Reach out on [Discord](https://discord.gg/ollama) or file an
 [issue](https://github.com/ollama/ollama/issues) for additional help.
@@ -133,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
@@ -164,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 GGUF file](#Importing-a-GGUF-based-model-or-adapter)
- [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 Safetensors model](#importing-a-model-from-safetensors-weights)
+- [Importing a GGUF model](#importing-a-gguf-model)
+- [Sharing models on ollama.com](#sharing-your-model-on-ollama-com)

 ## 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);
- Mistral (including Mistral 1, Mistral 2, and Mixtral);
- Gemma (including Gemma 1 and Gemma 2); and
- Phi3
+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).

-This includes importing foundation models as well as any fine tuned models which have been _fused_ with a foundation model.
-
-## 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:
+To import a single-file 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>
-ADAPTER /path/to/file.gguf
+FROM /path/to/model-*.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" />
-
-[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.
+Use open models in your desktop apps and coding agents, or build them into your application.

 <CardGroup cols={2}>
-  <Card title="Quickstart" icon="rocket" href="/quickstart">
-    Get up and running with your first model or integrate Ollama with your favorite tools
+  <Card title="Use your apps" icon="desktop" href="/quickstart#get-started">
+    Connect Claude or ChatGPT on your desktop, or launch a coding agent from your terminal.
  </Card>
-  <Card
-    title="Download Ollama"
-    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 title="Build an application" icon="code" href="/quickstart#build-an-application">
+    Call cloud models with Ollama, OpenAI, or Anthropic APIs.
  </Card>
 </CardGroup>

-## Libraries
+## Explore models
+
+Choose cloud models or run models on your computer.

 <CardGroup cols={2}>
-  <Card
-    title="Ollama's Python Library"
-    icon="python"
-    href="https://github.com/ollama/ollama-python"
-  >
-    The official library for using Ollama with Python
+  <Card title="Cloud models" icon="cloud" href="/cloud">
+    Run models without a local GPU.
  </Card>
-
-  <Card title="Ollama's JavaScript library" icon="js" href="https://github.com/ollama/ollama-js">
-    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 title="Local models" icon="hard-drive" href="/quickstart#run-a-model-locally">
+    Download Ollama and run a model on your computer.
  </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}>
-  <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>
+Join the conversation on [Discord](https://discord.gg/ollama) or [Reddit](https://reddit.com/r/ollama).
@@ -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 `glm-4.7`, `qwen3-coder`, `gpt-oss`. 
+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,25 +188,7 @@ irm https://claude.ai/install.ps1 | iex

 </CodeGroup>

-## Usage with Ollama
-
-### Quick setup
-
-```shell
-ollama launch claude
-```
-
-To configure without launching:
-
-```shell
-ollama launch claude --config
-```
-
-### Manual setup
-
-Claude Code connects to Ollama using the Anthropic-compatible API.
-
-1. Set the environment variables:
+<p className="manual-step-title">2. Set the environment variables</p>

 ```shell
 export ANTHROPIC_AUTH_TOKEN=ollama
@@ -50,26 +196,14 @@ 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 gpt-oss:20b
+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 qwen3-coder 
+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.
-
-## Recommended Models
-
- `qwen3-coder` 
- `glm-4.7`
- `gpt-oss:20b`
- `gpt-oss:120b`
-
-Cloud models are also available at [ollama.com/search?c=cloud](https://ollama.com/search?c=cloud).
-
@@ -0,0 +1,42 @@
+---
+title: Claude Desktop
+description: Use Ollama models in Claude on macOS.
+---
+
+
+## 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
+```
+
+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` 
- `deepseek-v3.1:671b`
+Choose a [cloud model](https://ollama.com/search?c=cloud) that supports tool calling.
@@ -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:
@@ -35,36 +44,47 @@ To use `codex` with Ollama, use the `--oss` flag:
 codex --oss
 ```

-### Changing Models
-
-By default, codex will use the local `gpt-oss:20b` model. However, you can specify a different model with the `-m` flag:
+To use a specific model, pass the `-m` flag:

 ```
 codex --oss -m gpt-oss:120b
 ```

-### Cloud Models
+To use a cloud model:

 ```
 codex --oss -m gpt-oss:120b-cloud
 ```

+### Profile-based setup

-## Connecting to ollama.com
-
-
-Create an [API key](https://ollama.com/settings/keys) from ollama.com and export it as `OLLAMA_API_KEY`.
-
-To use ollama.com directly, edit your `~/.codex/config.toml` file to point to ollama.com.
+For a persistent Codex CLI configuration, create `~/.codex/ollama-launch.config.toml`:

 ```toml
 model = "gpt-oss:120b"
-model_provider = "ollama"
+model_provider = "ollama-launch"
+model_catalog_json = "/Users/you/.codex/model.json"

-[model_providers.ollama]
+[model_providers.ollama-launch]
 name = "Ollama"
-base_url = "https://ollama.com/v1"
-env_key = "OLLAMA_API_KEY"
+base_url = "http://localhost:11434/v1/"
+wire_api = "responses"
 ```

-Run `codex` in a new terminal to load the new settings.
+Then run:
+
+```
+codex --profile ollama-launch
+```
+
+## 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,93 @@
+---
+title: Copilot CLI
+---
+
+GitHub Copilot CLI is GitHub's AI coding agent for the terminal. It can understand your codebase, make edits, run commands, and help you build software faster.
+
+Open models can be used with Copilot CLI through Ollama, enabling you to use models such as `qwen3.5`, `glm-5.1:cloud`, `kimi-k2.5:cloud`.
+
+## Install
+
+Install [Copilot CLI](https://github.com/features/copilot/cli/):
+
+<CodeGroup>
+
+```shell macOS / Linux (Homebrew)
+brew install copilot-cli
+```
+
+```shell npm (all platforms)
+npm install -g @github/copilot
+```
+
+```shell macOS / Linux (script)
+curl -fsSL https://gh.io/copilot-install | bash
+```
+
+```powershell Windows (WinGet)
+winget install GitHub.Copilot
+```
+
+</CodeGroup>
+
+## Usage with Ollama
+
+### Quick setup
+
+```shell
+ollama launch copilot
+```
+
+### Run directly with a model
+
+```shell
+ollama launch copilot --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 Copilot CLI without interaction for use in Docker, CI/CD, or scripts:
+
+```shell
+ollama launch copilot --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 Copilot CLI.
+
+## Manual setup
+
+Copilot CLI connects to Ollama using the OpenAI-compatible API via environment variables.
+
+1. Set the environment variables:
+
+```shell
+export COPILOT_PROVIDER_BASE_URL=http://localhost:11434/v1
+export COPILOT_PROVIDER_API_KEY=
+export COPILOT_PROVIDER_WIRE_API=responses
+export COPILOT_MODEL=qwen3.5
+```
+
+1. Run Copilot CLI:
+
+```shell
+copilot
+```
+
+Or run with environment variables inline:
+
+```shell
+COPILOT_PROVIDER_BASE_URL=http://localhost:11434/v1 COPILOT_PROVIDER_API_KEY= COPILOT_PROVIDER_WIRE_API=responses COPILOT_MODEL=glm-5:cloud copilot
+```
+
+**Note:** Copilot 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.
@@ -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
+```
@@ -0,0 +1,116 @@
+---
+title: Hermes Agent
+---
+
+Hermes Agent is a self-improving AI agent built by Nous Research. It features automatic skill creation, cross-session memory, and 70+ skills that it ships with by default. 
+
+![Hermes Agent with Ollama](/images/hermes.png)
+
+## Quick start
+
+```bash
+ollama launch hermes
+```
+
+Ollama handles everything automatically:
+
+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
+
+## Recommended models
+
+**Cloud models**:
+
+- `kimi-k2.5:cloud` — Multimodal reasoning with subagents
+- `glm-5.1:cloud` — Reasoning and code generation
+- `qwen3.5:cloud` — Reasoning, coding, and agentic tool use with vision
+- `minimax-m2.7:cloud` — Fast, efficient coding and real-world productivity
+
+**Local models:**
+
+- `gemma4` — Reasoning and code generation locally (~16 GB VRAM)
+- `qwen3.6` — Reasoning, coding, and visual understanding locally (~24 GB VRAM)
+
+More models at [ollama.com/search](https://ollama.com/search?c=cloud).
+
+## Connect messaging apps
+
+Link Telegram, Discord, Slack, WhatsApp, Signal, or Email to chat with your models from anywhere:
+
+```bash
+hermes gateway setup
+```
+
+## Reconfigure
+
+Use Hermes's model picker to change providers or models later:
+
+```bash
+hermes model
+```
+
+## Manual setup
+
+If you'd rather drive Hermes's own wizard instead of `ollama launch hermes`, install it directly:
+
+```bash
+curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
+```
+
+Hermes launches the setup wizard automatically. Choose **Quick setup**:
+
+```
+How would you like to set up Hermes?
+
+ →  Quick setup — provider, model & messaging (recommended)
+    Full setup — configure everything
+```
+
+### Connect to Ollama
+
+1. Select **More providers...**
+2. Select **Custom endpoint (enter URL manually)**
+3. Set the API base URL to the Ollama OpenAI-compatible endpoint:
+
+   ```
+   API base URL [e.g. https://api.example.com/v1]: http://127.0.0.1:11434/v1
+   ```
+
+4. Leave the API key blank (not required for local Ollama):
+
+   ```
+   API key [optional]:
+   ```
+
+5. Hermes auto-detects downloaded models, confirm the one you want:
+
+   ```
+   Verified endpoint via http://127.0.0.1:11434/v1/models (1 model(s) visible)
+     Detected model: kimi-k2.5:cloud
+     Use this model? [Y/n]:
+   ```
+
+6. Leave context length blank to auto-detect:
+
+   ```
+   Context length in tokens [leave blank for auto-detect]:
+   ```
+
+### Connect messaging
+
+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 gateway setup'
+```
+
+### Launch
+
+```
+Launch hermes chat now? [Y/n]: Y
+```
@@ -2,49 +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)
- [Codex](/integrations/codex)
- [OpenCode](/integrations/opencode)
- [Droid](/integrations/droid)
- [Goose](/integrations/goose)
+<CardGroup cols={2}>
+  <Card title="Claude Code" icon="/images/launch-icons/claude-code.svg" href="/integrations/claude-code">
+    Read code, edit files, and run commands.
+  </Card>

-## 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

-## 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)
- [Cline](/integrations/cline)
- [Roo Code](/integrations/roo-code)
- [JetBrains](/integrations/jetbrains)
- [Xcode](/integrations/xcode)
- [Zed](/integrations/zed)
+  <Card title="ChatGPT Desktop" icon="/images/launch-icons/chatgpt.svg" href="/integrations/chatgpt">
+    Use Ollama models in Codex mode.
+  </Card>
+</CardGroup>

-## 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)
-
-## Notebooks
-
-Interactive computing environments with AI capabilities.
-
- [marimo](/integrations/marimo)
+<CardGroup cols={2}>
+  <Card title="VS Code" icon="/images/launch-icons/vscode.svg" href="/integrations/vscode">
+    Install the Ollama extension to use models in VS Code Chat.
+  </Card>
+</CardGroup>
@@ -0,0 +1,67 @@
+---
+title: NemoClaw
+---
+
+NemoClaw is NVIDIA's open source security stack for [OpenClaw](/integrations/openclaw). It wraps OpenClaw with the NVIDIA OpenShell runtime to provide kernel-level sandboxing, network policy controls, and audit trails for AI agents. 
+
+## Quick start
+
+Pull a model:
+
+```bash
+ollama pull nemotron-3-nano:30b
+```
+
+Run the installer:
+
+```bash
+curl -fsSL https://www.nvidia.com/nemoclaw.sh | \
+  NEMOCLAW_NON_INTERACTIVE=1 \
+  NEMOCLAW_PROVIDER=ollama \
+  NEMOCLAW_MODEL=nemotron-3-nano:30b \
+  bash
+```
+
+Connect to your sandbox:
+
+```bash
+nemoclaw my-assistant connect
+```
+
+Open the TUI:
+
+```bash
+openclaw tui
+```
+
+<Note>Ollama support in NemoClaw is still experimental.</Note>
+
+## Platform support
+
+| Platform | Runtime | Status |
+|----------|---------|--------|
+| Linux (Ubuntu 22.04+) | Docker | Primary |
+| macOS (Apple Silicon) | Colima or Docker Desktop | Supported |
+| Windows | WSL2 with Docker Desktop | Supported |
+
+CMD and PowerShell are not supported on Windows — WSL2 is required.
+
+<Note>Ollama must be installed and running before the installer runs. When running inside WSL2 or a container, ensure Ollama is reachable from the sandbox (e.g. `OLLAMA_HOST=0.0.0.0`).</Note>
+
+## System requirements
+
+- CPU: 4 vCPU minimum
+- RAM: 8 GB minimum (16 GB recommended)
+- Disk: 20 GB free (40 GB recommended for local models)
+- Node.js 20+ and npm 10+
+- Container runtime (Docker preferred)
+
+## Recommended models
+
+- `nemotron-3-super:cloud` — Strong reasoning and coding
+- `qwen3.5:cloud` — 397B; reasoning and code generation
+- `nemotron-3-nano:30b` — Recommended local model; fits in 24 GB VRAM
+- `qwen3.5:27b` — Fast local reasoning (~18 GB VRAM)
+- `glm-4.7-flash` — Reasoning and code generation (~25 GB VRAM)
+
+More models at [ollama.com/search](https://ollama.com/search).
@@ -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
+```
@@ -4,47 +4,92 @@ title: OpenClaw

 OpenClaw is a personal AI assistant that runs on your own devices. It bridges messaging services (WhatsApp, Telegram, Slack, Discord, iMessage, and more) to AI coding agents through a centralized gateway.

-## Install
-
-Install [OpenClaw](https://openclaw.ai/) 
-
-```bash
-npm install -g openclaw@latest
-```
-
-Then run the onboarding wizard:
-
-```bash
-openclaw onboard --install-daemon
-```
-
-<Note>OpenClaw 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>
-
-## Usage with Ollama
-
-### Quick setup
+## Quick start

 ```bash
 ollama launch openclaw
 ```

+Ollama handles everything automatically:
+
+1. **Install** — If OpenClaw isn't installed, Ollama prompts to install it via npm
+2. **Security** — On the first launch, a security notice explains the risks of tool access
+3. **Model** — Pick a model from the selector (local or cloud)
+4. **Onboarding** — Ollama configures the provider, installs the gateway daemon, sets your model as the primary, and enables OpenClaw's bundled Ollama web search
+5. **Gateway** — Starts in the background and opens the OpenClaw TUI
+
+<Note>OpenClaw requires a larger context window. It is recommended to use a context window of at least 64k tokens if using local models. See [Context length](/context-length) for more information.</Note>
+
 <Note>Previously known as Clawdbot. `ollama launch clawdbot` still works as an alias.</Note>

-This configures OpenClaw to use Ollama and starts the gateway.
-If the gateway is already running, no changes need to be made as the gateway will auto-reload the changes. 
+## Web search and fetch

+OpenClaw ships with a bundled Ollama `web_search` provider that lets local or cloud-backed Ollama setups search the web through the configured Ollama host.

-To configure without launching:
+```bash
+ollama launch openclaw
+```

-```shell
+Ollama web search is enabled automatically when launching OpenClaw through Ollama. To configure it manually:
+
+```bash
+openclaw configure --section web
+```
+
+<Note>Ollama web search for local models requires `ollama signin`.</Note>
+
+## Configure without launching
+
+To change the model without starting the gateway and TUI:
+
+```bash
 ollama launch openclaw --config
 ```

-## Recommended Models
+To use a specific model directly:

- `qwen3-coder`
- `glm-4.7`
- `gpt-oss:20b`
- `gpt-oss:120b`
+```bash
+ollama launch openclaw --model kimi-k2.5:cloud
+```

-Cloud models are also available at [ollama.com/search?c=cloud](https://ollama.com/search?c=cloud).
+If the gateway is already running, it restarts automatically to pick up the new model.
+
+## Recommended models
+
+**Cloud models**:
+
+- `kimi-k2.5:cloud` — Multimodal reasoning with subagents
+- `qwen3.5:cloud` — Reasoning, coding, and agentic tool use with vision
+- `glm-5.1:cloud` — Reasoning and code generation
+- `minimax-m2.7:cloud` — Fast, efficient coding and real-world productivity
+
+**Local models:**
+
+- `gemma4` — Reasoning and code generation locally (~16 GB VRAM)
+- `qwen3.5` — Reasoning, coding, and visual understanding locally (~11 GB VRAM)
+
+More models at [ollama.com/search](https://ollama.com/search?c=cloud).
+
+## Non-interactive (headless) mode
+
+Run OpenClaw without interaction for use in Docker, CI/CD, or scripts:
+
+```bash
+ollama launch openclaw --model kimi-k2.5:cloud --yes
+```
+
+The `--yes` flag auto-pulls the model, skips selectors, and requires `--model` to be specified.
+
+## Connect messaging apps
+
+```bash
+openclaw configure --section channels
+```
+
+Link WhatsApp, Telegram, Slack, Discord, or iMessage to chat with your local models from anywhere.
+
+## Stopping the gateway
+
+```bash
+openclaw gateway stop
+```
@@ -2,105 +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
-curl -fsSL https://opencode.ai/install | bash
-```
+Launch OpenCode with Ollama:

-<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>
-
-## Usage with Ollama
-
-### Quick setup
-
-```bash
+```shell
 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
 ```

-### Manual setup
+### Configuration precedence

-Add a configuration block to `~/.config/opencode/opencode.json`:
+`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.

-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "provider": {
-    "ollama": {
-      "npm": "@ai-sdk/openai-compatible",
-      "name": "Ollama",
-      "options": {
-        "baseURL": "http://localhost:11434/v1"
-      },
-      "models": {
-        "qwen3-coder": {
-          "name": "qwen3-coder"
-        }
-      }
-    }
-  }
-}
-```
+Models defined only in `opencode.json` do not appear in the `ollama launch` model picker.

-## Cloud Models
-
-`glm-4.7:cloud` is the recommended model for use with OpenCode.
-
-Add the cloud configuration to `~/.config/opencode/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": {
-        "glm-4.7:cloud": {
-          "name": "glm-4.7:cloud"
-        }
-      }
-    }
-  }
-}
-```
-
-## Connecting to ollama.com
-
-1. Create an [API key](https://ollama.com/settings/keys) from ollama.com and export it as `OLLAMA_API_KEY`.
-2. Update `~/.config/opencode/opencode.json` to point to ollama.com:
-
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "provider": {
-    "ollama": {
-      "npm": "@ai-sdk/openai-compatible",
-      "name": "Ollama Cloud",
-      "options": {
-        "baseURL": "https://ollama.com/v1"
-      },
-      "models": {
-        "glm-4.7:cloud": {
-          "name": "glm-4.7:cloud"
-        }
-      }
-    }
-  }
-}
-```
-
-Run `opencode` in a new terminal to load the new settings.
+See OpenCode's [config precedence](https://opencode.ai/docs/config/#precedence-order).
@@ -0,0 +1,109 @@
+---
+title: Pi
+---
+
+Pi is a minimal and extensible coding agent.
+
+## Quick setup
+
+```bash
+ollama launch pi
+```
+
+This installs Pi if needed, configures Ollama as a provider including web tools, and drops you into an interactive session.
+
+To configure without launching:
+
+```shell
+ollama launch pi --config
+```
+
+### Run directly with a model
+
+```shell
+ollama launch pi --model qwen3.5:cloud
+```
+
+Cloud models are also available at [ollama.com](https://ollama.com/search?c=cloud).
+
+## Extensions 
+
+Pi ships with four core tools: `read`, `write`, `edit`, and `bash`. All other capabilities are added through its extension system.
+
+On-demand capability packages invoked via `/skill:name` commands.  
+
+Install from npm or git:
+
+```bash
+pi install npm:@foo/some-tools
+pi install git:github.com/user/repo@v1
+```
+
+See all packages at [pi.dev](https://pi.dev/packages) 
+
+### Web search
+
+Pi can use web search and fetch tools via the `@ollama/pi-web-search` package.
+
+When launching Pi through Ollama, package install/update is managed automatically.
+To install manually:
+
+```bash
+pi install npm:@ollama/pi-web-search
+```
+
+### Autoresearch with `pi-autoresearch`
+
+[pi-autoresearch](https://github.com/davebcn87/pi-autoresearch) brings autonomous experiment loops to Pi. Inspired by Karpathy's autoresearch, it turns any measurable metric into an optimization target: test speed, bundle size, build time, model training loss, Lighthouse scores.
+
+```bash
+pi install https://github.com/davebcn87/pi-autoresearch
+```
+
+Tell Pi what to optimize. It runs experiments, benchmarks each one, keeps improvements, reverts regressions, and repeats — all autonomously. A built-in dashboard tracks every run with confidence scoring to distinguish real gains from benchmark noise.
+
+```bash
+/autoresearch optimize unit test runtime
+```
+
+Each kept experiment is automatically committed. Each failed one is reverted. When you're done, Pi can group improvements into independent branches for clean review and merge.
+
+## 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
+{
+  "providers": {
+    "ollama": {
+      "baseUrl": "http://localhost:11434/v1",
+      "api": "openai-completions",
+      "apiKey": "ollama",
+      "models": [
+        {
+          "id": "qwen3-coder"
+        }
+      ]
+    }
+  }
+}
+```
+
+Update `~/.pi/agent/settings.json` to set the default provider:
+
+```json
+{
+  "defaultProvider": "ollama",
+  "defaultModel": "qwen3-coder"
+}
+```
@@ -0,0 +1,54 @@
+---
+title: Pool
+---
+
+Pool is Poolside's software agent for the terminal, built for enterprise development workflows.
+
+## Install
+
+Install [Pool](https://github.com/poolsideai/pool):
+
+## Usage with Ollama
+
+### Quick setup
+
+```shell
+ollama launch pool
+```
+
+### Run directly with a model
+
+```shell
+ollama launch pool --model kimi-k2.6:cloud
+```
+
+### Pass arguments through to Pool
+
+Arguments after `--` are passed directly to Pool:
+
+```shell
+ollama launch pool -- --help
+```
+
+## Manual setup
+
+Pool connects to Ollama using the OpenAI-compatible API via environment variables.
+
+1. Set the environment variables:
+
+```shell
+export POOLSIDE_STANDALONE_BASE_URL=http://localhost:11434/v1
+export POOLSIDE_API_KEY=ollama
+```
+
+2. Run Pool with an Ollama model:
+
+```shell
+pool -m kimi-k2.6:cloud
+```
+
+Or run with environment variables inline:
+
+```shell
+POOLSIDE_STANDALONE_BASE_URL=http://localhost:11434/v1 POOLSIDE_API_KEY=ollama pool -m kimi-k2.6:cloud
+```
@@ -2,33 +2,57 @@
 title: VS Code
 ---

-## Install
+Use Ollama models in VS Code Chat with the [Ollama extension](https://marketplace.visualstudio.com/items?itemName=Ollama.ollama).

-Install [VS Code](https://code.visualstudio.com/download).
+## Requirements

-## Usage with Ollama
+- [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

-1. Open Copilot side bar found in top right window
-   <div style={{ display: "flex", justifyContent: "center" }}>
-     <img
-       src="/images/vscode-sidebar.png"
-       alt="VS Code chat Sidebar"
-       width="75%"
-     />
-   </div>
-2. Select the model dropdown > **Manage models**
-   <div style={{ display: "flex", justifyContent: "center" }}>
-     <img
-       src="/images/vscode-models.png"
-       alt="VS Code model picker"
-       width="75%"
-     />
-   </div>
-3. Enter **Ollama** under **Provider Dropdown** and select desired models (e.g `qwen3, qwen3-coder:480b-cloud`)
-   <div style={{ display: "flex", justifyContent: "center" }}>
-     <img
-       src="/images/vscode-model-options.png"
-       alt="VS Code model options dropdown"
-       width="75%"
-     />
-   </div>
+Earlier VS Code versions do not reliably cancel requests from language model providers.
+
+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.
+
+## Install the extension
+
+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.
+
+The extension discovers models from `http://127.0.0.1:11434` by default.
+
+## Add a model
+
+Pull a local model:
+
+```shell
+ollama pull qwen3.6
+```
+
+To use a cloud model, pull it and sign in:
+
+```shell
+ollama pull kimi-k2.6:cloud
+ollama signin
+```
+
+Local models do not require sign-in.
+
+## Context length
+
+VS Code may show a model's maximum supported context length even when Ollama allocates a smaller context at runtime.
+
+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.
+
+## Troubleshooting
+
+If Ollama models do not appear in the model picker:
+
+1. Make sure Ollama is running.
+2. Run `ollama list` and confirm that models are available.
+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`.
@@ -101,7 +101,7 @@ nvidia-smi

 ### Install AMD ROCm drivers (optional)

-[Download and Install](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/tutorial/quick-start.html) ROCm v6.
+[Download and Install](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/tutorial/quick-start.html) ROCm v7.

 ### Start Ollama

@@ -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">
-  A list of available base models
-</Card>
-
-<Card title="Base Models" href="https://ollama.com/library">
-  Additional models can be found at
+<Card title="Model library" href="https://ollama.com/library">
+  Browse available models
 </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:
-
- 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
+#### Build from a GGUF model

 ```
 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,141 +2,300 @@
 title: Quickstart
 ---

-This quickstart will walk your through running your first model with Ollama. To get started, download Ollama on macOS, Windows or 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
-  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

-## Run a model
+[Download Ollama](https://ollama.com/download) for macOS, Windows, or Linux. Open the app, or get started from your terminal:
+
+```shell
+ollama
+```
+
+Follow the setup prompts. Sign in to use cloud models, or choose a local model.
+
+## Connect a desktop app
+
+On macOS, open Ollama and select **Apps**. Connect **Claude** or **ChatGPT (Desktop)**. Follow the prompts to install or restart the app.
+
+Choose your Ollama models in **Settings → Apps**.
+
+- [Claude Desktop](/integrations/claude-desktop) — use Ollama models in Claude.
+- [ChatGPT Desktop](/integrations/chatgpt) — use Ollama models in Codex mode. Regular Chat and voice use your usual ChatGPT connection.
+
+## Use a coding agent
+
+From your project directory, launch your agent:

 <Tabs>
-  <Tab title="CLI">
-    Open a terminal and run the command:
+  <Tab title="Claude Code">

-    ```sh
-    ollama run gemma3
-    ```
+```shell
+ollama launch claude
+```
+
+Ollama offers to install Claude Code if needed. See [Claude Code](/integrations/claude-code) for details.

  </Tab>
-  <Tab title="cURL">
-    ```sh
-    ollama pull gemma3
-    ```
+  <Tab title="Codex CLI">

-    Lastly, chat with the model:
+[Install Codex CLI](/integrations/codex#install) first, then launch it:

-    ```shell
-    curl http://localhost:11434/api/chat -d '{
-      "model": "gemma3",
-      "messages": [{
-        "role": "user",
-        "content": "Hello there!"
-      }],
-      "stream": false
-    }'
-    ```
+```shell
+ollama launch codex
+```
+
+See [Codex CLI](/integrations/codex) for setup.

  </Tab>
-  <Tab title="Python">
-    Start by downloading a model:
+  <Tab title="OpenCode">

-    ```sh
-    ollama pull gemma3
-    ```
+```shell
+ollama launch opencode
+```

-    Then install Ollama's Python library:
-
-    ```sh
-    pip install ollama
-    ```
-
-    Lastly, chat with the model:
-
-    ```python
-    from ollama import chat
-    from ollama import ChatResponse
-
-    response: ChatResponse = chat(model='gemma3', messages=[
-      {
-        'role': 'user',
-        'content': 'Why is the sky blue?',
-      },
-    ])
-    print(response['message']['content'])
-    # or access fields directly from the response object
-    print(response.message.content)
-    ```
-
-  </Tab>
-  <Tab title="JavaScript">
-    Start by downloading a model:
-
-    ```
-    ollama pull gemma3
-    ```
-
-    Then install the Ollama JavaScript library:
-    ```
-    npm i ollama
-    ```
-
-    Lastly, chat with the model:
-
-    ```shell
-    import ollama from 'ollama'
-
-    const response = await ollama.chat({
-      model: 'gemma3',
-      messages: [{ role: 'user', content: 'Why is the sky blue?' }],
-    })
-    console.log(response.message.content)
-    ```
+Ollama offers to install OpenCode if needed. See [OpenCode](/integrations/opencode) for details.

  </Tab>
 </Tabs>

-See a full list of available models [here](https://ollama.com/models).
+Choose a model when prompted, then try:

-## Coding 
-
-For coding use cases, we recommend using the `glm-4.7-flash` model. 
-
-Note: this model requires 23 GB of VRAM with 64000 tokens context length.
-```sh
-ollama pull glm-4.7-flash 
+```text
+Explain how this repository is organized.
 ```

-Alternatively, you can use a more powerful cloud model (with full context length):
-```sh
-ollama pull glm-4.7:cloud
+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"
 ```

-Use `ollama launch` to quickly set up a coding tool with Ollama models:
-
-```sh
-ollama launch
+```powershell Windows
+$env:OLLAMA_API_KEY = "your_api_key"
 ```

-### Supported integrations
+</CodeGroup>

- [OpenCode](/integrations/opencode) - Open-source coding assistant
- [Claude Code](/integrations/claude-code) - Anthropic's agentic coding tool
- [Codex](/integrations/codex) - OpenAI's coding assistant
- [Droid](/integrations/droid) - Factory's AI coding agent
+Keep your key on your application's server, outside browser code and source control.

-### Launch with a specific model
+### 2. Send a request

-```sh
-ollama launch claude --model glm-4.7-flash
+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
+  }'
 ```

-### Configure without launching
+Read the answer from `message.content`. See [Ollama's API and libraries](/api/introduction).

-```sh
-ollama launch claude --config
+  </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;
+}
@@ -114,11 +114,30 @@ If you are experiencing problems getting Ollama to correctly discover or use you
 - `OLLAMA_DEBUG=1` During GPU discovery additional information will be reported
 - Check dmesg for any errors from amdgpu or kfd drivers `sudo dmesg | grep -i amdgpu` and `sudo dmesg | grep -i kfd`

+### AMD Driver Version Mismatch
+
+If your AMD GPU is not detected on Linux and the server logs contain messages like:
+
+```
+msg="failure during GPU discovery" ... error="failed to finish discovery before timeout"
+msg="bootstrap discovery took" duration=30s ...
+```
+
+This typically means the system's AMD GPU driver is too old. Ollama bundles
+ROCm 7 linux libraries which require a compatible ROCm 7 kernel driver. If the
+system is running an older driver (ROCm 6.x or earlier), GPU initialization
+will hang during device discovery and eventually time out, causing Ollama to
+fall back to CPU.
+
+To resolve this, upgrade to the ROCm v7 driver using the `amdgpu-install`
+utility from [AMD's ROCm documentation](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/).
+After upgrading, reboot and restart Ollama.
+
 ## Multiple AMD GPUs

 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
- AMD Radeon Driver https://www.amd.com/en/support if you have a Radeon card
+- NVIDIA 551.61 or newer Drivers if you have an NVIDIA 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.
@@ -80,9 +88,13 @@ help you keep up to date.

 If you'd like to install or integrate Ollama as a service, a standalone
 `ollama-windows-amd64.zip` zip file is available containing only the Ollama CLI
-and GPU library dependencies for Nvidia. If you have an AMD GPU, also download
-and extract the additional ROCm package `ollama-windows-amd64-rocm.zip` into the
-same directory. This allows for embedding Ollama in existing applications, or
+and GPU library dependencies for Nvidia. Depending on your hardware, you may also
+need to download and extract additional packages into the same directory:
+
+- **AMD GPU**: `ollama-windows-amd64-rocm.zip`
+- **MLX (CUDA)**: `ollama-windows-amd64-mlx.zip`
+
+This allows for embedding Ollama in existing applications, or
 running it as a system service via `ollama serve` with tools such as
 [NSSM](https://nssm.cc/).
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
The Librarian	7c43dfec77	Sync ollama docs from 421faa02 on 2026-05-12	2026-05-12 04:00:09 +00:00
The Librarian	5fb5e0e5b8	Sync ollama docs from 9330bb91 on 2026-04-12	2026-04-12 04:00:07 +00:00
The Librarian	1c2aec910d	Sync ollama docs from 8f45236d on 2026-03-12	2026-03-12 04:00:04 +00:00
				`@@ -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>