diff --git a/CHANGELOG.md b/CHANGELOG.md
index c7f8955e..60fd1c15 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@
 
 ### Added
 
+- **Synthetic picture chunks at ingest under multimodal embedders.** `build_picture_chunks` (in `client/processing.py`) walks a `DoclingDocument`'s `pictures` and emits one synthetic `Chunk` per `PictureItem` with available bytes. Bytes ride on a `Chunk._picture_data` PrivateAttr (not serialized) so `embed_chunks` can route them through `embed_images` while text chunks keep going through `embed_documents`. Wired into the three ingest paths (`create_document`, `_create_document_from_file`, `_create_or_update_document_from_url`, `_update_document_with_chunks`, and `_rebuild_rechunk`) — guarded by `embedder.supports_images` so text-only configurations are unaffected. Snapshot/merge with `existing_picture_data` keeps picture chunks alive across rebuild round-trips. Picture chunks land in the same `chunks` table with the same vector dim as text chunks, so cross-modal search reuses the existing hybrid+RRF pipeline.
 - **Multimodal embedder support (`provider="mlx"` and `provider="vllm"`).** `EmbedderWrapper` gains `supports_images: bool`, `embed_image_query`, and `embed_images`. Two pluggable paths:
   - `provider="mlx"` — Apple Silicon, in-process via the new `[mlx]` optional extra (env-marker-guarded so `uv sync --all-extras` works on Linux/Windows/Intel-Mac without resolver errors). Loads any HF repo that ships an MLX `load_model.py` (default tested model: `jinaai/jina-embeddings-v4-mlx-8bit`, 2048-dim).
   - `provider="vllm"` — cross-platform, talks HTTP to a vLLM server's OpenAI-compatible `/v1/embeddings` endpoint with vLLM's `messages` superset (text or `image_url` content parts, base64 data URIs). Works with `Qwen/Qwen3-VL-Embedding-8B` and `jinaai/jina-embeddings-v4`. No Python ML deps added — uses `httpx`.
diff --git a/haiku_rag_slim/haiku/rag/client/__init__.py b/haiku_rag_slim/haiku/rag/client/__init__.py
index 017454aa..3987bc33 100644
--- a/haiku_rag_slim/haiku/rag/client/__init__.py
+++ b/haiku_rag_slim/haiku/rag/client/__init__.py
@@ -150,10 +150,21 @@ class HaikuRAG:
 
         return await convert(self._config, source, format=format)
 
-    async def chunk(self, docling_document: "DoclingDocument") -> list[Chunk]:
+    async def chunk(
+        self,
+        docling_document: "DoclingDocument",
+        *,
+        existing_picture_data: dict[str, bytes] | None = None,
+        document_id: str | None = None,
+    ) -> list[Chunk]:
         from haiku.rag.client.processing import chunk
 
-        return await chunk(self._config, docling_document)
+        return await chunk(
+            self._config,
+            docling_document,
+            existing_picture_data=existing_picture_data,
+            document_id=document_id,
+        )
 
     # =========================================================================
     # Title Generation
diff --git a/haiku_rag_slim/haiku/rag/client/documents.py b/haiku_rag_slim/haiku/rag/client/documents.py
index 2ec31611..bc50ec2a 100644
--- a/haiku_rag_slim/haiku/rag/client/documents.py
+++ b/haiku_rag_slim/haiku/rag/client/documents.py
@@ -79,6 +79,15 @@ async def _update_document_with_chunks(
     """
     assert document.id is not None, "Document ID is required for update"
 
+    # Snapshot existing picture bytes before deleting items so the post-delete
+    # extract_items can merge them back. Skip under pictures="none" so updates
+    # reclaim storage.
+    existing_picture_data: dict[str, bytes] | None = None
+    if docling_document is not None and client._config.processing.pictures != "none":
+        existing_picture_data = (
+            await client.document_item_repository.get_all_picture_data(document.id)
+        )
+
     chunks = await ensure_chunks_embedded(client._config, chunks)
 
     versions = await client.store.current_table_versions()
@@ -96,20 +105,7 @@ async def _update_document_with_chunks(
 
         await client.chunk_repository.create(chunks)
 
-        # Replace document items when a new DoclingDocument is provided.
-        # Snapshot existing picture bytes first so they survive the
-        # delete-and-re-extract cycle when the live docling has already had
-        # its picture URIs stripped (rebuild / round-trip scenarios). Under
-        # `pictures="none"` we skip the snapshot so updates reclaim storage.
         if docling_document is not None:
-            keep_picture_data = client._config.processing.pictures != "none"
-            existing_picture_data = (
-                await client.document_item_repository.get_all_picture_data(
-                    updated_doc.id
-                )
-                if keep_picture_data
-                else None
-            )
             await client.document_item_repository.delete_by_document_id(updated_doc.id)
             items = extract_items(
                 updated_doc.id,
diff --git a/haiku_rag_slim/haiku/rag/client/processing.py b/haiku_rag_slim/haiku/rag/client/processing.py
index b3aa59c5..df42befd 100644
--- a/haiku_rag_slim/haiku/rag/client/processing.py
+++ b/haiku_rag_slim/haiku/rag/client/processing.py
@@ -91,16 +91,118 @@ async def convert(
         return await converter.convert_text(source, format=format)
 
 
-async def chunk(config: AppConfig, docling_document: "DoclingDocument") -> list[Chunk]:
+async def chunk(
+    config: AppConfig,
+    docling_document: "DoclingDocument",
+    *,
+    existing_picture_data: dict[str, bytes] | None = None,
+    document_id: str | None = None,
+) -> list[Chunk]:
     """Chunk a DoclingDocument into Chunks.
 
-    Returns chunks without embeddings or document_id. Each chunk's `order`
-    field is set to its position in the list.
+    When the configured embedder supports images, also emit one synthetic
+    Chunk per ``PictureItem`` with available bytes (see ``build_picture_chunks``)
+    and merge them with text chunks in structural (``iterate_items()``) order.
+    ``chunk.order`` is the index in the merged list.
+
+    ``existing_picture_data`` (snapshot keyed by ``self_ref``) supplies bytes
+    for pictures whose ``image.uri`` has been stripped — used by the rebuild
+    path where the docling is loaded from the stored blob.
     """
     from haiku.rag.chunkers import get_chunker
+    from haiku.rag.embeddings import get_embedder
 
     chunker = get_chunker(config)
-    return await chunker.chunk(docling_document)
+    text_chunks = await chunker.chunk(docling_document)
+
+    if not get_embedder(config).supports_images:
+        for i, c in enumerate(text_chunks):
+            c.order = i
+        return text_chunks
+
+    picture_chunks = build_picture_chunks(
+        docling_document,
+        document_id=document_id,
+        existing_picture_data=existing_picture_data,
+    )
+
+    if not picture_chunks:
+        for i, c in enumerate(text_chunks):
+            c.order = i
+        return text_chunks
+
+    positions = {
+        item.self_ref: pos
+        for pos, (item, _level) in enumerate(docling_document.iterate_items())
+    }
+
+    def first_pos(c: Chunk) -> int:
+        refs = (c.metadata or {}).get("doc_item_refs") or []
+        return positions.get(refs[0], len(positions)) if refs else len(positions)
+
+    merged = sorted(text_chunks + picture_chunks, key=first_pos)
+    for i, c in enumerate(merged):
+        c.order = i
+    return merged
+
+
+def build_picture_chunks(
+    docling_document: "DoclingDocument",
+    *,
+    document_id: str | None = None,
+    existing_picture_data: dict[str, bytes] | None = None,
+) -> list[Chunk]:
+    """Emit one synthetic ``Chunk`` per ``PictureItem`` with available bytes.
+
+    Bytes come from ``picture.image.uri`` (live data URI on a freshly-converted
+    docling) or from ``existing_picture_data`` keyed by ``self_ref`` (snapshot
+    taken before a delete-and-re-extract cycle, when the live docling has had
+    its picture URIs stripped). Pictures with no available bytes are skipped.
+
+    The bytes ride on ``Chunk._picture_data`` (a PrivateAttr — not serialized)
+    so ``embed_chunks`` can route them through ``embed_image_query``. The
+    ``order`` field is left at its default (0); the caller (``chunk()``)
+    reassigns it after merging with text chunks in structural order.
+    """
+    from haiku.rag.store.models.document_item import (
+        _decode_picture_bytes,
+        extract_item_text,
+    )
+
+    existing = existing_picture_data or {}
+    chunks: list[Chunk] = []
+
+    for picture in docling_document.pictures:
+        picture_data = _decode_picture_bytes(picture)
+        if picture_data is None:
+            picture_data = existing.get(picture.self_ref)
+        if picture_data is None:
+            continue
+
+        text = extract_item_text(picture, docling_document) or ""
+
+        page_numbers: list[int] = []
+        if prov := getattr(picture, "prov", None):
+            for p in prov:
+                page_no = getattr(p, "page_no", None)
+                if page_no is not None and page_no not in page_numbers:
+                    page_numbers.append(page_no)
+
+        metadata = {
+            "doc_item_refs": [picture.self_ref],
+            "labels": ["picture"],
+            "page_numbers": sorted(page_numbers),
+            "headings": None,
+        }
+        chunk = Chunk(
+            document_id=document_id,
+            content=text,
+            metadata=metadata,
+        )
+        chunk._picture_data = picture_data
+        chunks.append(chunk)
+
+    return chunks
 
 
 async def ensure_chunks_embedded(config: AppConfig, chunks: list[Chunk]) -> list[Chunk]:
diff --git a/haiku_rag_slim/haiku/rag/client/rebuild.py b/haiku_rag_slim/haiku/rag/client/rebuild.py
index 92fc1630..af0f5ede 100644
--- a/haiku_rag_slim/haiku/rag/client/rebuild.py
+++ b/haiku_rag_slim/haiku/rag/client/rebuild.py
@@ -224,11 +224,12 @@ async def _rebuild_rechunk(
     client: "HaikuRAG", documents: list[Document]
 ) -> AsyncGenerator[str, None]:
     """Re-chunk and re-embed each document from its stored docling blob."""
-    from haiku.rag.embeddings import embed_chunks
+    from haiku.rag.embeddings import embed_chunks, get_embedder
 
     pending_chunks: list[Chunk] = []
     pending_docs: list[Document] = []
     pending_doc_ids: list[str] = []
+    embedder = get_embedder(client._config)
 
     for doc in documents:
         assert doc.id is not None
@@ -240,8 +241,18 @@ async def _rebuild_rechunk(
                 "requires it. Run a full rebuild (without --rechunk) instead."
             )
 
-        # Chunk and embed
-        chunks = await client.chunk(docling_document)
+        # Stored blob has stripped picture URIs; pass the snapshot so
+        # build_picture_chunks (inside chunk()) can recover the bytes.
+        existing_picture_data = (
+            await client.document_item_repository.get_all_picture_data(doc.id)
+            if embedder.supports_images
+            else None
+        )
+        chunks = await client.chunk(
+            docling_document,
+            existing_picture_data=existing_picture_data,
+            document_id=doc.id,
+        )
         embedded_chunks = await embed_chunks(chunks, client._config)
 
         # Prepare chunks with document_id and order
diff --git a/haiku_rag_slim/haiku/rag/embeddings/__init__.py b/haiku_rag_slim/haiku/rag/embeddings/__init__.py
index 74794750..2493e897 100644
--- a/haiku_rag_slim/haiku/rag/embeddings/__init__.py
+++ b/haiku_rag_slim/haiku/rag/embeddings/__init__.py
@@ -90,20 +90,12 @@ EMBEDDING_BATCH_SIZE = 512
 async def embed_chunks(
     chunks: list["Chunk"], config: AppConfig = Config
 ) -> list["Chunk"]:
-    """Generate embeddings for chunks.
+    """Generate embeddings for chunks, dispatching text vs picture variants.
 
-    Contextualizes chunks (prepends headings) before embedding for better
-    semantic search. Returns new Chunk objects with embeddings set.
-
-    Embeddings are generated in batches to avoid request size limits
-    and timeouts with large document sets.
-
-    Args:
-        chunks: List of chunks to embed.
-        config: Configuration for embedder selection.
-
-    Returns:
-        New list of Chunk objects with embedding field populated.
+    Text chunks are contextualized (headings prepended) and routed through
+    ``embed_documents``. Picture chunks (those carrying ``_picture_data``)
+    are routed through ``embed_images`` and require a multimodal embedder.
+    Vectors land in the original chunk order.
     """
     if not chunks:
         return []
@@ -111,15 +103,36 @@ async def embed_chunks(
     from haiku.rag.store.models.chunk import Chunk
 
     embedder = get_embedder(config)
-    texts = contextualize(chunks)
 
-    # Batch embedding calls to avoid request size limits
-    all_embeddings: list[list[float]] = []
-    for i in range(0, len(texts), EMBEDDING_BATCH_SIZE):
-        batch = texts[i : i + EMBEDDING_BATCH_SIZE]
-        batch_embeddings = await embedder.embed_documents(batch)
-        all_embeddings.extend(batch_embeddings)
+    text_chunks: list[Chunk] = []
+    picture_chunks: list[Chunk] = []
+    for chunk in chunks:
+        if chunk._picture_data is not None:
+            picture_chunks.append(chunk)
+        else:
+            text_chunks.append(chunk)
 
+    text_embeddings: list[list[float]] = []
+    if text_chunks:
+        texts = contextualize(text_chunks)
+        for i in range(0, len(texts), EMBEDDING_BATCH_SIZE):
+            batch = texts[i : i + EMBEDDING_BATCH_SIZE]
+            text_embeddings.extend(await embedder.embed_documents(batch))
+
+    picture_embeddings: list[list[float]] = []
+    if picture_chunks:
+        if not embedder.supports_images:
+            raise ValueError(
+                "Picture chunks require a multimodal embedder. Configure "
+                "provider='mlx' or provider='vllm', or omit picture chunks."
+            )
+        for chunk in picture_chunks:
+            picture_embeddings.append(
+                await embedder.embed_image_query(chunk._picture_data)
+            )
+
+    text_iter = iter(text_embeddings)
+    picture_iter = iter(picture_embeddings)
     return [
         Chunk(
             id=chunk.id,
@@ -130,9 +143,13 @@ async def embed_chunks(
             document_uri=chunk.document_uri,
             document_title=chunk.document_title,
             document_meta=chunk.document_meta,
-            embedding=embedding,
+            embedding=(
+                next(picture_iter)
+                if chunk._picture_data is not None
+                else next(text_iter)
+            ),
         )
-        for chunk, embedding in zip(chunks, all_embeddings)
+        for chunk in chunks
     ]
 
 
diff --git a/haiku_rag_slim/haiku/rag/store/models/chunk.py b/haiku_rag_slim/haiku/rag/store/models/chunk.py
index 7ee9a125..76e2a932 100644
--- a/haiku_rag_slim/haiku/rag/store/models/chunk.py
+++ b/haiku_rag_slim/haiku/rag/store/models/chunk.py
@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from pydantic import BaseModel
+from pydantic import BaseModel, PrivateAttr
 
 if TYPE_CHECKING:
     from docling_core.types.doc.document import DocItem, DoclingDocument
@@ -103,6 +103,11 @@ class Chunk(BaseModel):
     document_meta: dict = {}
     embedding: list[float] | None = None
 
+    # Transient: picture bytes for synthetic picture chunks. Set by
+    # build_picture_chunks; consumed by embed_chunks to route through
+    # embed_images. Excluded from serialization (PrivateAttr).
+    _picture_data: bytes | None = PrivateAttr(default=None)
+
     def get_chunk_metadata(self) -> ChunkMetadata:
         """Parse metadata dict into structured ChunkMetadata."""
         return ChunkMetadata.model_validate(self.metadata)
diff --git a/tests/cassettes/test_rebuild/test_rebuild_rechunk.yaml b/tests/cassettes/test_rebuild/test_rebuild_rechunk.yaml
index a7fa679f..2fb38b58 100644
--- a/tests/cassettes/test_rebuild/test_rebuild_rechunk.yaml
+++ b/tests/cassettes/test_rebuild/test_rebuild_rechunk.yaml
@@ -86,7 +86,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '4848'
+      - '4851'
       content-type:
       - application/json
       host:
@@ -104,7 +104,8 @@ interactions:
         Campaign strategies have taken an advanced turn as candidates leverage digital media to reach a wider audience. Hashtags, viral videos, targeted ads and targeted messaging can all play an influential role in changing public opinion with just a tweet or meme. At the grassroots level candidates engage in door-to-door campaigns personalized for individual voters in an attempt to connect.
       - |-
         Bintang's interactive app for gathering real-time feedback from citizens about daily commute challenges was applauded as an innovative form of civic engagement, while Harahap launched a series of webinars featuring experts discussing economic growth under his administration.
-        Rallies and Persuasion Jakartan politicians know the power of an impassioned speech cannot be underrated, and candidates have been taking full advantage of its effectiveness at rallies. Rallies feature vibrant colors, banners and impassioned discourse in an attempt to win converts over. At one high-spirited rally on October 22, Bintang outlined her policy plans for improving education and healthcare to an appreciative crowd while Harahap's rallies often consist of shows of solidarity from various political allies united behind his plea for continuity and stability.
+        Rallies and Persuasion
+        Jakartan politicians know the power of an impassioned speech cannot be underrated, and candidates have been taking full advantage of its effectiveness at rallies. Rallies feature vibrant colors, banners and impassioned discourse in an attempt to win converts over. At one high-spirited rally on October 22, Bintang outlined her policy plans for improving education and healthcare to an appreciative crowd while Harahap's rallies often consist of shows of solidarity from various political allies united behind his plea for continuity and stability.
         Debates: Clashes Between Visions and Policies
       - |-
         Debates are one of the highlights of Jakarta election campaigns, allowing candidates to outline their platforms and discuss critical issues. On November 5th, citizens witnessed an exhilarating debate between candidates Bintang and Harahap over whether the city was prepared for digital transformation in public services; Bintang advocated an aggressive move toward smart city model while Harahap advocated a more measured approach so as not to alienate less tech-savvy residents.
@@ -112,12 +113,15 @@ interactions:
         Ensuring every eligible voter is engaged and informed remains an ongoing challenge for Jakartans. Civil society groups and independent bodies host workshops and publish voter guides to inform voters of their rights and choices, while an annual democracy festival such as that held on November 20 featured interactive exhibits on Jakarta's electoral history as well as mock voting booths for first-time voters.
         Campaign Financing: Transparency and Accountability
       - |-
-        Campaign financing has always been a contentious topic in elections, and this election cycle is no exception. Bintang's campaign, funded largely through crowdfunders online supporters, stands in stark contrast with Harahap's sophisticated machine backed by both private donors and party funds. To protect democratic decision making processes from any undue influences on decision-making processes, Jakarta Election Commission mandated strict reporting and transparency measures during campaign financing decisions.
+        Campaign financing has always been a contentious topic in elections, and this election cycle is no exception. Bintang's campaign, funded largely through crowdfunders online supporters, stands in stark contrast with Harahap's sophisticated machine backed by both private donors and party funds. To protect democratic decision making processes from any
+        undue influences on decision-making processes, Jakarta Election Commission mandated strict reporting and transparency measures during campaign financing decisions.
         Before Election Day: Submit Final Appeals Now
         As election day nears, candidates make their last appeals to voters. Bintang plans a visit through key neighborhoods while Harahap plans a final rally scheduled for late November. Both camps are honing their messaging and policy proposals while encouraging supporters to make an appearance at polling booths on November 8th.
         Polling Day: The Final Act of Campaign Activities
         On December 6th, voting booths across Jakarta will open their doors, signalling the culmination of weeks of intense campaigning. Voters will cast their vote and candidates await results that depend on how effective their strategies, speeches and outreach initiatives have been.
-        Jakarta's vibrant election campaign offers an insight into its flourishing democracy. As the city looks ahead to an exciting new chapter in its political history, electoral processes demonstrate the significance of people-power in shaping our collective futures.
+      - Jakarta's vibrant election campaign offers an insight into its flourishing democracy. As the city looks ahead to an
+        exciting new chapter in its political history, electoral processes demonstrate the significance of people-power in
+        shaping our collective futures.
       model: qwen3-embedding:4b
     uri: http://localhost:11434/v1/embeddings
   response:
@@ -131,20 +135,23 @@ interactions:
       - embedding: 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
         index: 0
         object: embedding
-      - embedding: 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
+      - embedding: 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
         index: 1
         object: embedding
       - embedding: 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
         index: 2
         object: embedding
-      - embedding: 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
+      - embedding: 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
         index: 3
         object: embedding
+      - embedding: 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
+        index: 4
+        object: embedding
       model: qwen3-embedding:4b
       object: list
       usage:
-        prompt_tokens: 854
-        total_tokens: 854
+        prompt_tokens: 858
+        total_tokens: 858
     status:
       code: 200
       message: OK
diff --git a/tests/test_picture_in_context.py b/tests/test_picture_in_context.py
index e36085f3..18b0b77a 100644
--- a/tests/test_picture_in_context.py
+++ b/tests/test_picture_in_context.py
@@ -322,6 +322,252 @@ async def test_search_tool_returns_multimodal_when_picture_present():
     assert part.data == PICTURE_BYTES
 
 
+# B2: synthetic picture chunks at ingestion
+
+
+def test_build_picture_chunks_uses_live_uri():
+    from haiku.rag.client.processing import build_picture_chunks
+    from tests.store.test_document_items import _docling_doc_with_picture
+
+    doc = _docling_doc_with_picture()
+    chunks = build_picture_chunks(doc, document_id="doc-1")
+
+    assert len(chunks) == 1
+    chunk = chunks[0]
+    assert chunk.metadata["doc_item_refs"] == ["#/pictures/0"]
+    assert chunk.metadata["labels"] == ["picture"]
+    assert chunk._picture_data is not None
+    assert chunk._picture_data.startswith(b"\x89PNG")
+    assert chunk.document_id == "doc-1"
+
+
+def test_build_picture_chunks_falls_back_to_existing_picture_data():
+    """When the live docling has its picture URIs stripped, the snapshot
+    fills the gap so rebuild round-trips don't lose picture chunks."""
+    from haiku.rag.client.processing import build_picture_chunks
+    from tests.store.test_document_items import _docling_doc_with_picture
+
+    doc = _docling_doc_with_picture()
+    for picture in doc.pictures:
+        picture.image = None
+
+    chunks = build_picture_chunks(
+        doc,
+        document_id="doc-1",
+        existing_picture_data={"#/pictures/0": b"snapshot-bytes"},
+    )
+
+    assert len(chunks) == 1
+    assert chunks[0]._picture_data == b"snapshot-bytes"
+
+
+def test_build_picture_chunks_skips_pictures_without_bytes():
+    from haiku.rag.client.processing import build_picture_chunks
+    from tests.store.test_document_items import _docling_doc_with_picture
+
+    doc = _docling_doc_with_picture()
+    for picture in doc.pictures:
+        picture.image = None
+
+    chunks = build_picture_chunks(doc, document_id="doc-1")
+    assert chunks == []
+
+
+@pytest.mark.asyncio
+async def test_chunk_interleaves_picture_in_structural_order(monkeypatch):
+    """``chunk()`` merges text and picture chunks by their first
+    ``doc_item_ref``'s position in ``iterate_items()``, so picture chunks
+    sit where they appear in the document, not appended at the end.
+    """
+    from haiku.rag.client.processing import chunk
+    from haiku.rag.config import AppConfig
+    from haiku.rag.embeddings import EmbedderWrapper
+    from haiku.rag.store.models.chunk import Chunk
+
+    class StubMultimodalEmbedder(EmbedderWrapper):
+        supports_images = True
+
+        def __init__(self):
+            super().__init__(embedder=None, vector_dim=4)
+
+    class StubChunker:
+        async def chunk(self, document):
+            # Two text chunks straddling the picture's structural position.
+            # iterate_items order on the fixture below: texts/0, texts/1,
+            # pictures/0, texts/2 — positions 0,1,2,3.
+            return [
+                Chunk(
+                    content="before",
+                    metadata={"doc_item_refs": ["#/texts/0", "#/texts/1"]},
+                ),
+                Chunk(
+                    content="after",
+                    metadata={"doc_item_refs": ["#/texts/2"]},
+                ),
+            ]
+
+    monkeypatch.setattr(
+        "haiku.rag.embeddings.get_embedder",
+        lambda *a, **kw: StubMultimodalEmbedder(),
+    )
+    monkeypatch.setattr(
+        "haiku.rag.chunkers.get_chunker", lambda *a, **kw: StubChunker()
+    )
+
+    from docling_core.types.doc.document import DoclingDocument, ImageRef
+    from docling_core.types.doc.labels import DocItemLabel
+    from PIL import Image as PILImageModule
+
+    img = PILImageModule.new("RGB", (8, 8), "blue")
+    doc = DoclingDocument(name="ordered")
+    doc.add_text(label=DocItemLabel.PARAGRAPH, text="A")
+    doc.add_text(label=DocItemLabel.PARAGRAPH, text="B")
+    doc.add_picture(image=ImageRef.from_pil(img, dpi=72))
+    doc.add_text(label=DocItemLabel.PARAGRAPH, text="C")
+
+    chunks = await chunk(AppConfig(), doc)
+
+    contents = [c.content for c in chunks]
+    assert contents == ["before", "", "after"], (
+        f"expected [before, picture, after], got {contents}"
+    )
+    assert chunks[1].metadata["labels"] == ["picture"]
+    assert chunks[1].metadata["doc_item_refs"] == ["#/pictures/0"]
+    assert chunks[1]._picture_data is not None
+    # chunk.order matches list index after the merge sort.
+    for i, c in enumerate(chunks):
+        assert c.order == i
+
+
+@pytest.mark.asyncio
+async def test_embed_chunks_dispatches_text_vs_picture(monkeypatch):
+    """embed_chunks routes text chunks through embed_documents (batched) and
+    picture chunks through embed_image_query (one at a time), reassembling
+    in original order."""
+    from haiku.rag.embeddings import EmbedderWrapper, embed_chunks
+    from haiku.rag.store.models.chunk import Chunk
+
+    text_calls: list[list[str]] = []
+    image_calls: list[bytes] = []
+
+    class StubEmbedder(EmbedderWrapper):
+        supports_images = True
+
+        def __init__(self):
+            super().__init__(embedder=None, vector_dim=4)
+
+        async def embed_documents(self, texts):
+            text_calls.append(list(texts))
+            return [[0.1, 0.2, 0.3, 0.4] for _ in texts]
+
+        async def embed_image_query(self, image):
+            image_calls.append(image)
+            return [0.9, 0.8, 0.7, 0.6]
+
+    monkeypatch.setattr(
+        "haiku.rag.embeddings.get_embedder", lambda *a, **kw: StubEmbedder()
+    )
+
+    text_chunk = Chunk(content="hello", order=0)
+    pic_chunk = Chunk(
+        content="figure 1",
+        metadata={"labels": ["picture"], "doc_item_refs": ["#/pictures/0"]},
+        order=1,
+    )
+    pic_chunk._picture_data = b"PNGBYTES"
+
+    embedded = await embed_chunks([text_chunk, pic_chunk, text_chunk.model_copy()])
+
+    assert len(embedded) == 3
+    assert embedded[0].embedding == [0.1, 0.2, 0.3, 0.4]
+    assert embedded[1].embedding == [0.9, 0.8, 0.7, 0.6]
+    assert embedded[2].embedding == [0.1, 0.2, 0.3, 0.4]
+    assert text_calls == [["hello", "hello"]]
+    assert image_calls == [b"PNGBYTES"]
+
+
+@pytest.mark.asyncio
+async def test_embed_chunks_raises_on_picture_chunks_with_text_only_embedder(
+    monkeypatch,
+):
+    from haiku.rag.embeddings import EmbedderWrapper, embed_chunks
+    from haiku.rag.store.models.chunk import Chunk
+
+    class TextOnlyEmbedder(EmbedderWrapper):
+        def __init__(self):
+            super().__init__(embedder=None, vector_dim=4)
+
+        async def embed_documents(self, texts):
+            return [[0.0] * 4 for _ in texts]
+
+    monkeypatch.setattr(
+        "haiku.rag.embeddings.get_embedder", lambda *a, **kw: TextOnlyEmbedder()
+    )
+
+    pic_chunk = Chunk(content="x", metadata={"labels": ["picture"]}, order=0)
+    pic_chunk._picture_data = b"PNG"
+    with pytest.raises(ValueError, match="multimodal embedder"):
+        await embed_chunks([pic_chunk])
+
+
+@pytest.mark.asyncio
+async def test_ingest_emits_picture_chunks_with_multimodal_embedder(
+    temp_db_path, monkeypatch
+):
+    """End-to-end: ingest a docling doc with one picture under a stub
+    multimodal embedder; chunks_table contains a picture-labelled chunk
+    pointing at the picture's self_ref."""
+    from haiku.rag.client.documents import _store_document_with_chunks
+    from haiku.rag.embeddings import EmbedderWrapper, embed_chunks
+    from haiku.rag.store.models.document import Document
+    from tests.store.test_document_items import _docling_doc_with_picture
+
+    class StubMultimodalEmbedder(EmbedderWrapper):
+        supports_images = True
+
+        def __init__(self):
+            super().__init__(embedder=None, vector_dim=4)
+
+        async def embed_documents(self, texts):
+            return [[0.1] * 4 for _ in texts]
+
+        async def embed_image_query(self, image):
+            return [0.9] * 4
+
+    monkeypatch.setattr(
+        "haiku.rag.embeddings.get_embedder",
+        lambda *a, **kw: StubMultimodalEmbedder(),
+    )
+
+    docling_doc = _docling_doc_with_picture()
+
+    from haiku.rag.config import AppConfig, EmbeddingModelConfig, EmbeddingsConfig
+
+    config = AppConfig(
+        embeddings=EmbeddingsConfig(
+            model=EmbeddingModelConfig(provider="ollama", name="stub", vector_dim=4)
+        )
+    )
+    config.processing.pictures = "image"
+
+    async with HaikuRAG(temp_db_path, config=config, create=True) as rag:
+        chunks = await rag.chunk(docling_doc)
+        embedded = await embed_chunks(chunks, rag._config)
+
+        document = Document(content="x", uri="test://doc")
+        document.set_docling(docling_doc)
+        await _store_document_with_chunks(rag, document, embedded, docling_doc)
+
+        all_db_chunks = await rag.chunk_repository.store.chunks_table.query().to_list()
+        picture_db_chunks = [
+            c for c in all_db_chunks if "picture" in (c.get("metadata") or "")
+        ]
+        assert len(picture_db_chunks) >= 1
+        assert any(
+            "#/pictures/0" in (c.get("metadata") or "") for c in picture_db_chunks
+        )
+
+
 @pytest.mark.asyncio
 async def test_search_tool_returns_plain_string_when_no_pictures():
     """When no result carries image_data the tool returns a plain str (no