@@ -19,7 +19,7 @@ Models differ in what they are good at and what they cost. `text-embedding-3-sma
 
 Two things worth knowing before you build on it. Vectors are only comparable when they come from the same model at the same size, so changing either means re-embedding everything you intend to compare. And input longer than the model's limit is shortened to fit rather than rejected, with a warning in the run, so chunk long documents yourself when the tail matters.
 
-Ollama is the exception to most of the above. It runs on your own deployment, so it needs no API key and costs nothing, and the model list is whatever you have pulled onto that server rather than a catalog Sim maintains — the block reads it live, drops the models that report a non-embedding capability, and shows each one's vector width next to its name where Ollama reports one. A server too old to report either will list its chat models too and label none of them, so check the model you pick. Ollama accepts neither a task type nor a size reduction, so the block does not offer those controls for it. Self-hosted deployments configure the server with `OLLAMA_URL`; on Sim Cloud there is no Ollama to reach, so the list comes back empty.
+Ollama is the exception to most of the above. It runs on your own deployment, so it needs no API key and adds no provider charge — Sim's own per-run charge still applies — and the model list is whatever you have pulled onto that server rather than a catalog Sim maintains. The block reads it live, drops the models that report a non-embedding capability, and shows each one's vector width next to its name where Ollama reports one. A server too old to report either will list its chat models too and label none of them, so check the model you pick. The block offers no task-type or dimension control for Ollama: task conditioning has no equivalent there, and while recent Ollama builds do accept a dimension override for Matryoshka models, older ones silently ignore it, so Sim uses each model's own width rather than one that may or may not take effect. Self-hosted deployments configure the server with `OLLAMA_URL`; on Sim Cloud there is no Ollama to reach, so the list comes back empty.
 
 Sim's knowledge bases embed separately: a base fixes one model and one vector width when it is created, from a smaller set of models. This block is for embedding text yourself inside a workflow.
 {/* MANUAL-CONTENT-END */}
 
@@ -199,9 +199,11 @@ Both variables apply at creation time and are recorded on the knowledge base, so
 affects new knowledge bases only. Existing ones keep the model and width they were built with, and
 knowledge bases with different settings cannot be searched together.
 
-Matching the width to the model is yours to get right. Sim only knows the widths a hosted provider
-documents, and nothing at all about a model on your Ollama, so a mismatch surfaces as a failed
-document rather than a rejected configuration. Common pairings:
+Matching the width to the model is yours to get right for a hosted provider: Sim knows only the
+widths each one documents, so a width that model cannot emit falls back to `1536` with a warning.
+For Ollama it is checked — leave `EMBEDDING_OUTPUT_DIMS` unset and Sim reads the model's width from
+your server, refusing to create the knowledge base if it cannot; set it explicitly and a mismatch
+surfaces as a failed document instead. Common pairings:
 
 | `EMBEDDING_OUTPUT_DIMS` | Works with |
 |----------|-------------|
 
@@ -250,7 +250,7 @@ The load balancer's backend timeout is closing them. On GKE, attach a `BackendCo
 
 ## Knowledge base upload fails
 
-Embeddings need a provider — set `OPENAI_API_KEY`, configure Azure OpenAI, set `KB_EMBEDDING_MODEL=gemini-embedding-001` with a Gemini key, or set `KB_EMBEDDING_MODEL=ollama/<model>` with `OLLAMA_URL` to embed on your own Ollama. If one is configured, verify pgvector is installed on the database.
+Embeddings need a provider — set `OPENAI_API_KEY`, configure Azure OpenAI, set `KB_EMBEDDING_MODEL=gemini-embedding-001` with a Gemini key, or set `KB_EMBEDDING_MODEL=ollama/<model>` with `OLLAMA_URL` to embed on your own Ollama. On a self-hosted deployment `OPENROUTER_API_KEY` also serves the OpenAI-family models on its own, as a fallback behind any OpenAI or Azure credentials you have. If one is configured, verify pgvector is installed on the database.
 
 A document that fails with `vector 0 has N unexpected dimensions` means `EMBEDDING_OUTPUT_DIMS` does not match what the model actually emits. The message names both widths. If the width the model returned is one of `384`, `768`, `1024`, `1536`, or `3072`, set the variable to it and recreate the knowledge base. If it is anything else, no column can store it — choose a model that emits one of those five instead, since setting an unstorable width silently falls back to `1536` and the next document fails the same way. Existing knowledge bases keep the width they were created with.
 
 
@@ -276,6 +276,14 @@ export const EmbeddingsBlock: BlockConfig<EmbeddingsResponse> = {
           return {
             input: params.input,
             model,
+            /**
+             * Explicitly cleared, not omitted: the executor merges this over the
+             * saved inputs, so an omitted key leaves the previous provider's
+             * credential in place and serializes it into a request that has no
+             * use for one.
+             */
+            apiKey: undefined,
+            openRouterApiKey: undefined,
             taskType: undefined,
             dimensions: undefined,
           }
 
@@ -8,6 +8,7 @@ import {
   getOllamaEmbeddingModelMetadata,
   OllamaEmbeddingModelNotFoundError,
   OllamaEmbeddingWidthUnknownError,
+  OllamaUnreachableError,
 } from '@/lib/embeddings/ollama-model-catalog.server'
 
 const fetchMock = vi.fn()
@@ -23,7 +24,8 @@ function serve(
       )
     }
     const { model } = JSON.parse(String(init?.body)) as { model: string }
-    const detail = models[model]
+    /** Ollama resolves a bare name to its `:latest` tag server-side. */
+    const detail = models[model] ?? models[`${model}:latest`]
     if (!detail) return Promise.resolve(new Response('not found', { status: 404 }))
     return Promise.resolve(
       Response.json({
@@ -112,7 +114,8 @@ describe('Ollama embedding model catalog', () => {
     await expect(fetchOllamaEmbeddingModelCatalog()).resolves.toEqual([])
   })
 
-  it('resolves a bare name against the tag Ollama installed it under', async () => {
+  /** Ollama resolves a bare name to its `:latest` tag itself, so Sim need not. */
+  it('accepts a bare name and a routing-prefixed one alike', async () => {
     serve({
       'all-minilm:latest': {
         capabilities: ['embedding'],
@@ -121,11 +124,11 @@ describe('Ollama embedding model catalog', () => {
     })
 
     await expect(getOllamaEmbeddingModelMetadata('all-minilm')).resolves.toEqual({
-      id: 'all-minilm:latest',
+      id: 'all-minilm',
       dimensions: 384,
     })
     await expect(getOllamaEmbeddingModelMetadata('ollama/all-minilm')).resolves.toEqual({
-      id: 'all-minilm:latest',
+      id: 'all-minilm',
       dimensions: 384,
     })
   })
@@ -138,6 +141,41 @@ describe('Ollama embedding model catalog', () => {
     )
   })
 
+  /**
+   * Resolution asks about one model rather than listing the server, so an
+   * unrelated model's slow or failing `/api/show` cannot delay or break it.
+   */
+  it('asks only about the selected model, never the whole catalog', async () => {
+    serve({
+      'all-minilm:latest': {
+        capabilities: ['embedding'],
+        modelInfo: { 'bert.embedding_length': 384 },
+      },
+    })
+
+    await getOllamaEmbeddingModelMetadata('all-minilm')
+
+    const paths = fetchMock.mock.calls.map(([url]) => String(url))
+    expect(paths.every((url) => url.endsWith('/api/show'))).toBe(true)
+    expect(paths).toHaveLength(1)
+  })
+
+  it('reports a server that stops answering as an outage, not a missing model', async () => {
+    fetchMock.mockRejectedValue(new Error('ECONNREFUSED'))
+
+    await expect(getOllamaEmbeddingModelMetadata('all-minilm')).rejects.toBeInstanceOf(
+      OllamaUnreachableError
+    )
+  })
+
+  it('rejects a chat model asked for by name', async () => {
+    serve({ 'smollm2:135m': { capabilities: ['completion'] } })
+
+    await expect(getOllamaEmbeddingModelMetadata('smollm2:135m')).rejects.toBeInstanceOf(
+      OllamaEmbeddingModelNotFoundError
+    )
+  })
+
   /**
    * The width is what the client validates the response against, so a model
    * whose width cannot be read is refused rather than embedded unchecked.
 
@@ -154,8 +154,15 @@ async function loadOllamaEmbeddingModelCatalog(
 }
 
 /**
- * Resolves one selected model against the server's live catalog, the way the
- * OpenRouter tool resolves a model against OpenRouter's.
+ * Resolves one selected model, the way the OpenRouter tool resolves a model
+ * against OpenRouter's catalog — but by asking `/api/show` for that model alone.
+ *
+ * Deliberately not a catalog scan: this runs on every Ollama embedding request,
+ * and listing the server would make one unrelated model's slow or failing
+ * `/api/show` delay or break an embedding that never involved it. Asking
+ * directly also keeps the failures separable, which a scan cannot do — an
+ * absent model comes back 404 and is the caller's to fix, while anything else
+ * is the server's problem and must not be reported as a bad request.
  *
  * The width is required rather than optional because it is what the client
  * validates the response against. Without it a model that quietly returns a
@@ -167,14 +174,29 @@ export async function getOllamaEmbeddingModelMetadata(
   signal?: AbortSignal
 ): Promise<Required<OllamaEmbeddingModel>> {
   const name = isOllamaEmbeddingModel(model) ? ollamaEmbeddingModelName(model) : model
-  const { models, unreachable } = await loadOllamaEmbeddingModelCatalog(signal)
-  /** An empty catalog because nothing answered is an outage, not a missing model. */
-  if (unreachable !== undefined) throw new OllamaUnreachableError(unreachable)
-  /** Ollama resolves a bare name to its `:latest` tag, so both spellings match. */
-  const metadata = models.find(
-    (candidate) => candidate.id === name || candidate.id === `${name}:latest`
-  )
-  if (!metadata) throw new OllamaEmbeddingModelNotFoundError(name)
-  if (metadata.dimensions === undefined) throw new OllamaEmbeddingWidthUnknownError(name)
-  return { id: metadata.id, dimensions: metadata.dimensions }
+  if (!name) throw new OllamaEmbeddingModelNotFoundError(model)
+
+  let detail: { capabilities?: string[]; model_info?: Record<string, unknown> }
+  try {
+    detail = ollamaShowUpstreamResponseSchema.parse(
+      await fetchOllamaJson(
+        '/api/show',
+        { method: 'POST', body: JSON.stringify({ model: name }) },
+        signal
+      )
+    )
+  } catch (error) {
+    signal?.throwIfAborted()
+    const cause = getErrorMessage(error, 'Unknown error')
+    /** Ollama answers 404 for a model it does not have; anything else is its problem. */
+    if (cause.includes('404')) throw new OllamaEmbeddingModelNotFoundError(name)
+    throw new OllamaUnreachableError(cause)
+  }
+
+  if (detail.capabilities && !detail.capabilities.includes('embedding')) {
+    throw new OllamaEmbeddingModelNotFoundError(name)
+  }
+  const dimensions = readEmbeddingLength(detail.model_info)
+  if (dimensions === undefined) throw new OllamaEmbeddingWidthUnknownError(name)
+  return { id: name, dimensions }
 }
@@ -0,0 +1,145 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockEnv, mockOllamaMetadata } = vi.hoisted(() => ({
+  mockEnv: {} as { KB_EMBEDDING_MODEL?: string; EMBEDDING_OUTPUT_DIMS?: string },
+  mockOllamaMetadata: vi.fn(),
+}))
+
+/**
+ * `envNumber` is the real implementation, not a stub: the whole point of the
+ * cases below is that `createEnv` runs with `skipValidation`, so every value
+ * arrives as the raw string from the environment however its schema is declared.
+ */
+vi.mock('@/lib/core/config/env', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@/lib/core/config/env')>()),
+  env: mockEnv,
+}))
+
+vi.mock('@/lib/embeddings/ollama-model-catalog.server', () => ({
+  getOllamaEmbeddingModelMetadata: mockOllamaMetadata,
+}))
+
+import { getConfiguredKbEmbedding } from '@/lib/knowledge/embeddings'
+
+describe('getConfiguredKbEmbedding', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockEnv.KB_EMBEDDING_MODEL = undefined
+    mockEnv.EMBEDDING_OUTPUT_DIMS = undefined
+    mockOllamaMetadata.mockRejectedValue(new Error('no server configured'))
+  })
+
+  it('defaults to the model and width knowledge bases were always created at', async () => {
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'text-embedding-3-small',
+      dimensions: 1536,
+    })
+  })
+
+  it('stores at the configured width when the model can emit it', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'text-embedding-3-large'
+    mockEnv.EMBEDDING_OUTPUT_DIMS = '3072'
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'text-embedding-3-large',
+      dimensions: 3072,
+    })
+  })
+
+  it('accepts any storable width from a model on the deployment’s own Ollama', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'ollama/nomic-embed-text'
+    mockEnv.EMBEDDING_OUTPUT_DIMS = '768'
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'ollama/nomic-embed-text',
+      dimensions: 768,
+    })
+  })
+
+  /**
+   * Sim can read a local model's width off the server it is installed on, so an
+   * unstated width is resolved rather than defaulted — defaulting would create
+   * every base at 1,536 and fail each document against a 768-wide model.
+   */
+  it('reads an unstated Ollama width from the server the model is installed on', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'ollama/nomic-embed-text'
+    mockOllamaMetadata.mockResolvedValue({ id: 'nomic-embed-text:latest', dimensions: 768 })
+
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'ollama/nomic-embed-text',
+      dimensions: 768,
+    })
+    expect(mockOllamaMetadata).toHaveBeenCalledWith('ollama/nomic-embed-text')
+  })
+
+  it('prefers a stated width over the server, and never asks when one is stated', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'ollama/nomic-embed-text'
+    mockEnv.EMBEDDING_OUTPUT_DIMS = '1024'
+    mockOllamaMetadata.mockResolvedValue({ id: 'nomic-embed-text:latest', dimensions: 768 })
+
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'ollama/nomic-embed-text',
+      dimensions: 1024,
+    })
+    expect(mockOllamaMetadata).not.toHaveBeenCalled()
+  })
+
+  /**
+   * There is no width to fall back to: the adapter cannot ask Ollama for a
+   * different one, so the platform default would pin the base at a width the
+   * model does not emit and fail every document. Refusing is recoverable;
+   * a base created at an impossible width is not.
+   */
+  it('refuses to create a base when the server cannot be asked', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'ollama/nomic-embed-text'
+    mockOllamaMetadata.mockRejectedValue(new Error('ECONNREFUSED'))
+
+    await expect(getConfiguredKbEmbedding()).rejects.toThrow('Set EMBEDDING_OUTPUT_DIMS')
+  })
+
+  it('refuses to create a base when the model emits a width no column can store', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'ollama/odd-width'
+    mockOllamaMetadata.mockResolvedValue({ id: 'odd-width:latest', dimensions: 1152 })
+
+    await expect(getConfiguredKbEmbedding()).rejects.toThrow(
+      'emits 1152-dimensional vectors, which knowledge bases cannot store'
+    )
+  })
+
+  it('falls back when the width is not a number at all', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'text-embedding-3-large'
+    mockEnv.EMBEDDING_OUTPUT_DIMS = 'wide'
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'text-embedding-3-large',
+      dimensions: 1536,
+    })
+  })
+
+  it('falls back when the width has no storage column, keeping the chosen model', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'text-embedding-3-large'
+    mockEnv.EMBEDDING_OUTPUT_DIMS = '1000'
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'text-embedding-3-large',
+      dimensions: 1536,
+    })
+  })
+
+  it('falls back when the model cannot emit the configured width', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'gemini-embedding-001'
+    mockEnv.EMBEDDING_OUTPUT_DIMS = '1024'
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'gemini-embedding-001',
+      dimensions: 1536,
+    })
+  })
+
+  it('falls back to the default model when the configured one cannot index a knowledge base', async () => {
+    mockEnv.KB_EMBEDDING_MODEL = 'text-embedding-ada-002'
+    mockEnv.EMBEDDING_OUTPUT_DIMS = '768'
+    await expect(getConfiguredKbEmbedding()).resolves.toEqual({
+      model: 'text-embedding-3-small',
+      dimensions: 768,
+    })
+  })
+})