diff --git a/README.md b/README.md
index 05e7fb1..826d40f 100644
--- a/README.md
+++ b/README.md
@@ -138,6 +138,8 @@ below are generated from those pages, so this README and the pages never drift.
 <!-- GENERATED:CONNECTORS -->
 <!-- Generated from docs/connectors/*.md by scripts/sync_readme.py — do not edit by hand. -->
 
+### Memory & RAG
+
 <details>
 <summary><strong>Supermemory</strong> — documents → server-side embedding, idempotent on the canonical id</summary>
 
@@ -215,35 +217,87 @@ Decision: [`rac/decisions/`](rac/decisions) — ADR-004 (Mem0 backend, resync id
 </details>
 
 <details>
-<summary><strong>Zep</strong> — documents → a Zep knowledge graph; idempotent by graph resync</summary>
+<summary><strong>Qdrant</strong> — documents → external embedding → a Qdrant collection; idempotent on the canonical id</summary>
 
 A one-way, outbound push of the `rac export --documents` stream into
-[Zep Cloud](https://getzep.com). Same stream and flags as the other documents
-backends, a different subcommand:
+[Qdrant](https://qdrant.tech), the open-source vector database.
+
+Qdrant stores vectors but does **not** produce them (unlike Supermemory/Mem0/Zep,
+which embed server-side). So this connector embeds each record's text through a
+**configured external embedding service** — any OpenAI-compatible `/embeddings`
+endpoint, with a [LiteLLM](https://litellm.ai) gateway the reference deployment —
+then upserts the vector. The model and credentials live in that endpoint, never
+in RAC (the engine stays AI-optional, rac-core ADR-002/ADR-066); see
+[ADR-009](rac/decisions/adr-009-vector-store-connectors-embed-externally.md).
 
 ```bash
-pip install 'rac-connectors[zep]'
-export ZEP_API_KEY=z_...
+pip install 'rac-connectors[qdrant]'
+export QDRANT_URL=http://localhost:6333          # and QDRANT_API_KEY if your server needs auth
+export RAC_EMBED_BASE_URL=https://your-litellm/v1 # OpenAI-compatible /embeddings endpoint
+export RAC_EMBED_MODEL=text-embedding-3-small      # whatever your gateway routes
+export RAC_EMBED_API_KEY=sk-...                    # if the endpoint requires auth
+
+rac export rac/ --documents | rac-connect qdrant            # embed + upsert every record
+rac export rac/ --documents | rac-connect qdrant --dry-run  # preview, no embed, no API call
+rac-connect qdrant --input corpus.jsonl                     # read a file, not stdin
+```
+
+Each record maps to one Qdrant point:
 
-rac export rac/ --documents | rac-connect zep            # upsert every record
-rac export rac/ --documents | rac-connect zep --dry-run  # preview, no API call
-rac-connect zep --input corpus.jsonl                     # read a file, not stdin
+```
+record → upsert(point_id=uuid5(canonical id),
+                vector=embed(text),
+                payload={rac_id, type, status, title, text, …metadata})
 ```
 
-- **A corpus maps to a Zep graph.** A `source` becomes a Zep `graph_id`; each
-  record is added as a `type="text"` episode carrying the canonical `rac_id`,
-  `type`, `status`, and `title` in metadata.
-- **Idempotent by graph resync.** Zep has no per-record upsert key, so each push
-  deletes and recreates the corpus graph, then re-adds — re-running never
-  duplicates.
-- **No embeddings here.** Zep derives its knowledge graph and embeds; the
-  connector only ships text + metadata. Zep's copy is an associative index, not a
-  citation — authoritative text is always re-fetched from Lore.
-- **Auth via `ZEP_API_KEY`** — never hard-coded.
+| Flag | Meaning |
+|---|---|
+| `--dry-run` | Print what would be sent; embed nothing and call no API. |
+| `--input`, `-i` | Read JSONL from a file (default: stdin; `-` also means stdin). |
+| `--strict` | Fail on a malformed line instead of skipping it. |
+| `--verbose`, `-v` | Print per-record actions on a live push too. |
 
-Decision: [`rac/decisions/`](rac/decisions) — ADR-005 (Zep backend, graph-resync idempotency).
+- **Idempotent on the canonical `id`.** The point id is `uuid5(id)`, so a re-push
+  upserts in place rather than duplicating.
+- **One collection per corpus `source`** (falling back to `lore`); the collection
+  is created on first use with the embedder's vector dimension and cosine distance.
+- **Embeddings live in the external endpoint**, not here. **Pin the embedding
+  model** — the vectors, and the collection's dimension, are tied to it; changing
+  the model means re-embedding the corpus.
+- **Auth via `QDRANT_URL` / `QDRANT_API_KEY`** and the `RAC_EMBED_*` variables —
+  never hard-coded.
 
-**Full page:** [`docs/connectors/zep.md`](docs/connectors/zep.md)
+### Live smoke test
+
+The connector is wired and unit-tested against fakes, but the live path (a real
+Qdrant plus a real embeddings endpoint) is unproven until someone runs it — this
+page is `drafted (live run pending)`. To validate end to end:
+
+1. **Start Qdrant:** `docker run -p 6333:6333 qdrant/qdrant`.
+2. **Pick an embeddings endpoint** — a LiteLLM (or any OpenAI-compatible)
+   `/embeddings` gateway; note the model and its vector dimension.
+3. **Configure the environment:**
+
+   ```bash
+   export QDRANT_URL=http://localhost:6333       # + QDRANT_API_KEY if needed
+   export RAC_EMBED_BASE_URL=https://your-litellm/v1
+   export RAC_EMBED_MODEL=text-embedding-3-small
+   export RAC_EMBED_API_KEY=sk-...                # if the endpoint requires it
+   ```
+
+4. **Dry-run first** (no embed, no calls) — confirms records and collections:
+   `rac export rac/ --documents | rac-connect qdrant --dry-run`.
+5. **Live push:** `rac export rac/ --documents | rac-connect qdrant`.
+6. **Verify in Qdrant:** the collection (named after the corpus `source`,
+   default `lore`) exists with the model's vector size; the point count equals the
+   artifact count; a point's payload carries `rac_id`, `type`, `status`, `title`,
+   and `text`.
+7. **Re-run the push** and confirm the point count is unchanged — the upsert is
+   idempotent on `uuid5(rac_id)`.
+
+Then flip this page's `status` to `shipped`.
+
+**Full page:** [`docs/connectors/qdrant.md`](docs/connectors/qdrant.md)
 
 </details>
 
@@ -281,6 +335,41 @@ Decision: [`rac/decisions/`](rac/decisions) — ADR-006 (Letta backend, archive-
 
 </details>
 
+### Knowledge graph
+
+<details>
+<summary><strong>Zep</strong> — documents → a Zep knowledge graph; idempotent by graph resync</summary>
+
+A one-way, outbound push of the `rac export --documents` stream into
+[Zep Cloud](https://getzep.com). Same stream and flags as the other documents
+backends, a different subcommand:
+
+```bash
+pip install 'rac-connectors[zep]'
+export ZEP_API_KEY=z_...
+
+rac export rac/ --documents | rac-connect zep            # upsert every record
+rac export rac/ --documents | rac-connect zep --dry-run  # preview, no API call
+rac-connect zep --input corpus.jsonl                     # read a file, not stdin
+```
+
+- **A corpus maps to a Zep graph.** A `source` becomes a Zep `graph_id`; each
+  record is added as a `type="text"` episode carrying the canonical `rac_id`,
+  `type`, `status`, and `title` in metadata.
+- **Idempotent by graph resync.** Zep has no per-record upsert key, so each push
+  deletes and recreates the corpus graph, then re-adds — re-running never
+  duplicates.
+- **No embeddings here.** Zep derives its knowledge graph and embeds; the
+  connector only ships text + metadata. Zep's copy is an associative index, not a
+  citation — authoritative text is always re-fetched from Lore.
+- **Auth via `ZEP_API_KEY`** — never hard-coded.
+
+Decision: [`rac/decisions/`](rac/decisions) — ADR-005 (Zep backend, graph-resync idempotency).
+
+**Full page:** [`docs/connectors/zep.md`](docs/connectors/zep.md)
+
+</details>
+
 <details>
 <summary><strong>Cognee</strong> — documents → a Cognee knowledge graph; content-hash idempotent</summary>
 
diff --git a/docs/connectors/cognee.md b/docs/connectors/cognee.md
index 730b221..ca552bc 100644
--- a/docs/connectors/cognee.md
+++ b/docs/connectors/cognee.md
@@ -1,6 +1,7 @@
 <!-- rac-connector
 name: Cognee
 tagline: documents → a Cognee knowledge graph; content-hash idempotent
+category: Knowledge graph
 extra: cognee
 order: 50
 status: drafted (live run pending)
diff --git a/docs/connectors/letta.md b/docs/connectors/letta.md
index c4776bf..b4958b3 100644
--- a/docs/connectors/letta.md
+++ b/docs/connectors/letta.md
@@ -1,6 +1,7 @@
 <!-- rac-connector
 name: Letta
 tagline: documents → Letta archives (cloud or self-hosted); idempotent by archive resync
+category: Memory & RAG
 extra: letta
 order: 40
 status: drafted (live run pending)
diff --git a/docs/connectors/mem0.md b/docs/connectors/mem0.md
index 7f51b36..695790c 100644
--- a/docs/connectors/mem0.md
+++ b/docs/connectors/mem0.md
@@ -1,6 +1,7 @@
 <!-- rac-connector
 name: Mem0
 tagline: documents → server-side embedding; idempotent by container resync
+category: Memory & RAG
 extra: mem0
 order: 20
 status: drafted (live run pending)
diff --git a/docs/connectors/neo4j.md b/docs/connectors/neo4j.md
index 4560efd..3bcf8d4 100644
--- a/docs/connectors/neo4j.md
+++ b/docs/connectors/neo4j.md
@@ -1,6 +1,7 @@
 <!-- rac-connector
 name: Neo4j
 tagline: graph → typed nodes & edges via Cypher MERGE; idempotent on the canonical id
+category: Knowledge graph
 extra: neo4j
 order: 60
 status: drafted (live run pending)
diff --git a/docs/connectors/qdrant.md b/docs/connectors/qdrant.md
new file mode 100644
index 0000000..965e4c6
--- /dev/null
+++ b/docs/connectors/qdrant.md
@@ -0,0 +1,87 @@
+<!-- rac-connector
+name: Qdrant
+tagline: documents → external embedding → a Qdrant collection; idempotent on the canonical id
+category: Memory & RAG
+extra: qdrant
+order: 25
+status: drafted (live run pending)
+-->
+# Qdrant
+
+A one-way, outbound push of the `rac export --documents` stream into
+[Qdrant](https://qdrant.tech), the open-source vector database.
+
+Qdrant stores vectors but does **not** produce them (unlike Supermemory/Mem0/Zep,
+which embed server-side). So this connector embeds each record's text through a
+**configured external embedding service** — any OpenAI-compatible `/embeddings`
+endpoint, with a [LiteLLM](https://litellm.ai) gateway the reference deployment —
+then upserts the vector. The model and credentials live in that endpoint, never
+in RAC (the engine stays AI-optional, rac-core ADR-002/ADR-066); see
+[ADR-009](../../rac/decisions/adr-009-vector-store-connectors-embed-externally.md).
+
+```bash
+pip install 'rac-connectors[qdrant]'
+export QDRANT_URL=http://localhost:6333          # and QDRANT_API_KEY if your server needs auth
+export RAC_EMBED_BASE_URL=https://your-litellm/v1 # OpenAI-compatible /embeddings endpoint
+export RAC_EMBED_MODEL=text-embedding-3-small      # whatever your gateway routes
+export RAC_EMBED_API_KEY=sk-...                    # if the endpoint requires auth
+
+rac export rac/ --documents | rac-connect qdrant            # embed + upsert every record
+rac export rac/ --documents | rac-connect qdrant --dry-run  # preview, no embed, no API call
+rac-connect qdrant --input corpus.jsonl                     # read a file, not stdin
+```
+
+Each record maps to one Qdrant point:
+
+```
+record → upsert(point_id=uuid5(canonical id),
+                vector=embed(text),
+                payload={rac_id, type, status, title, text, …metadata})
+```
+
+| Flag | Meaning |
+|---|---|
+| `--dry-run` | Print what would be sent; embed nothing and call no API. |
+| `--input`, `-i` | Read JSONL from a file (default: stdin; `-` also means stdin). |
+| `--strict` | Fail on a malformed line instead of skipping it. |
+| `--verbose`, `-v` | Print per-record actions on a live push too. |
+
+- **Idempotent on the canonical `id`.** The point id is `uuid5(id)`, so a re-push
+  upserts in place rather than duplicating.
+- **One collection per corpus `source`** (falling back to `lore`); the collection
+  is created on first use with the embedder's vector dimension and cosine distance.
+- **Embeddings live in the external endpoint**, not here. **Pin the embedding
+  model** — the vectors, and the collection's dimension, are tied to it; changing
+  the model means re-embedding the corpus.
+- **Auth via `QDRANT_URL` / `QDRANT_API_KEY`** and the `RAC_EMBED_*` variables —
+  never hard-coded.
+
+### Live smoke test
+
+The connector is wired and unit-tested against fakes, but the live path (a real
+Qdrant plus a real embeddings endpoint) is unproven until someone runs it — this
+page is `drafted (live run pending)`. To validate end to end:
+
+1. **Start Qdrant:** `docker run -p 6333:6333 qdrant/qdrant`.
+2. **Pick an embeddings endpoint** — a LiteLLM (or any OpenAI-compatible)
+   `/embeddings` gateway; note the model and its vector dimension.
+3. **Configure the environment:**
+
+   ```bash
+   export QDRANT_URL=http://localhost:6333       # + QDRANT_API_KEY if needed
+   export RAC_EMBED_BASE_URL=https://your-litellm/v1
+   export RAC_EMBED_MODEL=text-embedding-3-small
+   export RAC_EMBED_API_KEY=sk-...                # if the endpoint requires it
+   ```
+
+4. **Dry-run first** (no embed, no calls) — confirms records and collections:
+   `rac export rac/ --documents | rac-connect qdrant --dry-run`.
+5. **Live push:** `rac export rac/ --documents | rac-connect qdrant`.
+6. **Verify in Qdrant:** the collection (named after the corpus `source`,
+   default `lore`) exists with the model's vector size; the point count equals the
+   artifact count; a point's payload carries `rac_id`, `type`, `status`, `title`,
+   and `text`.
+7. **Re-run the push** and confirm the point count is unchanged — the upsert is
+   idempotent on `uuid5(rac_id)`.
+
+Then flip this page's `status` to `shipped`.
diff --git a/docs/connectors/supermemory.md b/docs/connectors/supermemory.md
index 77d841d..81a4b60 100644
--- a/docs/connectors/supermemory.md
+++ b/docs/connectors/supermemory.md
@@ -1,6 +1,7 @@
 <!-- rac-connector
 name: Supermemory
 tagline: documents → server-side embedding, idempotent on the canonical id
+category: Memory & RAG
 extra: supermemory
 order: 10
 status: shipped
diff --git a/docs/connectors/zep.md b/docs/connectors/zep.md
index c8c52fe..527478f 100644
--- a/docs/connectors/zep.md
+++ b/docs/connectors/zep.md
@@ -1,6 +1,7 @@
 <!-- rac-connector
 name: Zep
 tagline: documents → a Zep knowledge graph; idempotent by graph resync
+category: Knowledge graph
 extra: zep
 order: 30
 status: drafted (live run pending)
diff --git a/pyproject.toml b/pyproject.toml
index 2db02b8..2685b82 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -53,6 +53,10 @@ letta = ["letta-client>=1,<2"]
 # The live Cognee push needs the cognee pipeline; the core install and the
 # fake-driven test-suite stay dependency-free. Pinned to the verified v1 major.
 cognee = ["cognee>=1,<2"]
+# The live Qdrant push needs the official client; the core install and the
+# fake-driven test-suite stay dependency-free. Embeddings come from an external
+# endpoint over stdlib HTTP (no SDK), so only qdrant-client is required here.
+qdrant = ["qdrant-client>=1.7,<2"]
 dev = ["pytest>=7.0", "ruff", "mypy"]
 
 [project.scripts]
@@ -91,5 +95,6 @@ module = [
     "zep_cloud.*",
     "letta_client.*",
     "cognee.*",
+    "qdrant_client.*",
 ]
 ignore_missing_imports = true
diff --git a/rac/decisions/adr-009-vector-store-connectors-embed-externally.md b/rac/decisions/adr-009-vector-store-connectors-embed-externally.md
new file mode 100644
index 0000000..481bf56
--- /dev/null
+++ b/rac/decisions/adr-009-vector-store-connectors-embed-externally.md
@@ -0,0 +1,106 @@
+---
+schema_version: 1
+id: LCON-KWC2WD0WAYRA
+type: decision
+---
+# ADR-009: Vector-Store Connectors Embed via an External Service
+
+## Context
+
+Every documents backend so far embeds **server-side** — Supermemory, Mem0, and
+Zep each take text and produce the vectors themselves. That is what let the
+connectors stay model-free: the seam (ADR-002) ships text and metadata, and
+"no embeddings, vectors, or model calls happen here — those live in the backend"
+holds, consistent with the engine's AI-optional stance (rac-core ADR-002) and its
+no-embeddings rule (rac-core ADR-066).
+
+A **bare vector store breaks that assumption.** Qdrant — the first, and the
+open-source target — stores vectors but does not produce them. Self-hosted
+open-source Qdrant has no server-side embedding (Qdrant Cloud Inference is a
+cloud-only feature), so the vectors must be supplied. A vector-store connector
+therefore has to obtain an embedding somewhere before it can upsert. This decision
+records how, generically, so Qdrant and any future vector store follow one rule
+rather than each re-litigating it.
+
+## Decision
+
+Vector-store connectors embed each record's text by calling a **configured
+external embedding service**, and that is an explicit, scoped exception to the
+model-free connector invariant.
+
+1. **External, OpenAI-compatible endpoint.** The connector POSTs text to a
+   configured `/embeddings` endpoint and upserts the returned vectors. A
+   [LiteLLM](https://litellm.ai) gateway is the reference deployment, mirroring
+   the grounding benchmark's `*_BASE_URL` proxy pattern; any OpenAI-compatible
+   endpoint works. The endpoint, model, and credentials are environment config
+   (`RAC_EMBED_BASE_URL`, `RAC_EMBED_MODEL`, `RAC_EMBED_API_KEY`) — they live in
+   the deployment, never in RAC.
+2. **No bundled model, no provider SDK.** The embedding seam
+   (`rac_connectors.embedding.Embedder`) is a small Protocol with a stdlib-HTTP
+   adapter, so RAC gains no model and no dependency; the connector depends only on
+   the Protocol and the test-suite drives a fake.
+3. **Scoped exception only.** This applies solely to vector-store connectors that
+   need vectors. Server-side-embedding backends stay model-free, and the engine
+   (rac-core ADR-002/ADR-066) is unchanged — RAC still ships no model and makes no
+   model call of its own.
+4. **Pin the model.** Vectors, and the vector store's collection dimension, are
+   tied to the embedding model; it must be pinned, and changing it means
+   re-embedding the corpus.
+
+## Consequences
+
+### Positive
+
+- Qdrant — and any future vector store — becomes integrable on the existing
+  `Connector.push` seam.
+- Provider-neutral: the gateway (LiteLLM, OpenAI, Ollama, …) is chosen and
+  swapped in the deployment with no connector change; keys and model stay
+  external to RAC.
+- No dependency weight: only the vector store's own client is an extra; the
+  embedding call is stdlib HTTP.
+
+### Negative
+
+- A live push to a vector store now requires a reachable external embedding
+  endpoint — these connectors are no longer model-free.
+- Reproducibility depends on the pinned model (and the gateway's routing), not on
+  RAC alone.
+
+### Risks
+
+- An embedding model is changed silently and the collection's vectors become
+  inconsistent. Mitigation: pin the model, document that a change requires a
+  re-embed, and keep the collection dimension derived from the live vector size.
+
+## Status
+
+Accepted
+
+## Category
+
+Architecture
+
+## Alternatives Considered
+
+### Bundle a local embedding model (e.g. fastembed) as the default
+
+Rejected as the default: it pulls a model and its runtime into RAC, is heavier and
+less neutral, and bakes a model choice into the connector. An external endpoint
+keeps RAC model-free and lets the deployment own the model; a bundled local option
+can still be added later behind the same `Embedder` seam.
+
+### Require server-side embedding (Qdrant Cloud Inference only)
+
+Rejected: it would exclude self-hosted open-source Qdrant — the open-source target
+— so it does not actually solve the integration.
+
+## Related Decisions
+
+- adr-001
+- adr-002
+
+## Review Date
+
+Revisit if a vector store gains a server-side embedding path worth adopting, or if
+a bundled local-embedding option is wanted as an alternative behind the `Embedder`
+seam.
diff --git a/scripts/sync_readme.py b/scripts/sync_readme.py
index 21695c0..d499b06 100644
--- a/scripts/sync_readme.py
+++ b/scripts/sync_readme.py
@@ -16,11 +16,18 @@
     python scripts/sync_readme.py            # rewrite the README region
     python scripts/sync_readme.py --check     # CI: fail if the README is stale
 
+Connectors are grouped in the README by ``category`` (kind, e.g. "Memory & RAG",
+"Knowledge graph") rather than by direction, so a provider that does both ingest
+and export (e.g. Atlassian) sits in a single kind group; its direction is
+described in its own page. Kind headings are ordered by the lowest ``order`` in
+each kind.
+
 Each page starts with an HTML-comment metadata block (hidden when rendered)::
 
     <!-- rac-connector
     name: Supermemory
     tagline: one-line summary shown in the <summary>
+    category: Memory & RAG
     extra: supermemory
     order: 10
     status: shipped
@@ -56,6 +63,7 @@
 class Page:
     name: str
     tagline: str
+    category: str
     order: int
     body: str
     path: Path
@@ -121,6 +129,7 @@ def load_pages() -> list[Page]:
             Page(
                 name=name,
                 tagline=tagline,
+                category=meta.get("category", "Other"),
                 order=int(meta.get("order", "999")),
                 body=body,
                 path=path,
@@ -132,20 +141,31 @@ def load_pages() -> list[Page]:
 
 def render(pages: list[Page]) -> str:
     blocks = [START, _NOTE, ""]
+    # Group by kind (category). Pages arrive sorted by (order, name); the kind
+    # headings are data-driven — each kind sorts by the lowest `order` among its
+    # pages — so a new page (e.g. an Atlassian provider) slots its kind into
+    # place via its `order` alone, with no change here. A provider that spans
+    # both ingest and export lives in one kind group; its direction is described
+    # in its own page, not the grouping.
+    groups: dict[str, list[Page]] = {}
     for page in pages:
-        rel = page.path.relative_to(ROOT).as_posix()
-        body = _rewrite_links(page.body, page.path.parent)
-        blocks += [
-            "<details>",
-            f"<summary><strong>{page.name}</strong> — {page.tagline}</summary>",
-            "",
-            body,
-            "",
-            f"**Full page:** [`{rel}`]({rel})",
-            "",
-            "</details>",
-            "",
-        ]
+        groups.setdefault(page.category, []).append(page)
+    for category in sorted(groups, key=lambda c: min(p.order for p in groups[c])):
+        blocks += [f"### {category}", ""]
+        for page in groups[category]:
+            rel = page.path.relative_to(ROOT).as_posix()
+            body = _rewrite_links(page.body, page.path.parent)
+            blocks += [
+                "<details>",
+                f"<summary><strong>{page.name}</strong> — {page.tagline}</summary>",
+                "",
+                body,
+                "",
+                f"**Full page:** [`{rel}`]({rel})",
+                "",
+                "</details>",
+                "",
+            ]
     blocks.append(END)
     return "\n".join(blocks)
 
diff --git a/src/rac_connectors/cli.py b/src/rac_connectors/cli.py
index d923393..3dadfd1 100644
--- a/src/rac_connectors/cli.py
+++ b/src/rac_connectors/cli.py
@@ -20,6 +20,7 @@
 from .cognee import CogneeConnector
 from .cognee.client import MissingCredentialsError as CogneeMissingCredentialsError
 from .cognee.client import client_from_env as cognee_client_from_env
+from .embedding import MissingEmbeddingConfigError, embedder_from_env
 from .graph import MalformedGraphError, parse_graph
 from .letta import LettaConnector
 from .letta.client import MissingCredentialsError as LettaMissingCredentialsError
@@ -30,6 +31,9 @@
 from .neo4j import Neo4jConnector
 from .neo4j.client import MissingCredentialsError
 from .neo4j.client import client_from_env as neo4j_client_from_env
+from .qdrant import QdrantConnector
+from .qdrant.client import MissingCredentialsError as QdrantMissingCredentialsError
+from .qdrant.client import client_from_env as qdrant_client_from_env
 from .records import MalformedRecordError, Record, parse_documents
 from .supermemory import SupermemoryConnector
 from .supermemory.client import MissingApiKeyError, client_from_env
@@ -127,6 +131,36 @@ def _run_mem0(args: argparse.Namespace) -> int:
     return 0
 
 
+def _run_qdrant(args: argparse.Namespace) -> int:
+    connector: Connector = QdrantConnector()
+    stream, owned = _open_stream(args.input)
+    try:
+        if not args.dry_run:
+            try:
+                connector = QdrantConnector(
+                    qdrant_client_from_env(), embedder_from_env()
+                )
+            except (QdrantMissingCredentialsError, MissingEmbeddingConfigError) as exc:
+                print(f"error: {exc}", file=sys.stderr)
+                return 2
+        try:
+            summary = _push_with_skips(
+                connector, stream, dry_run=args.dry_run, strict=args.strict
+            )
+        except MalformedRecordError as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            return 1
+    finally:
+        if owned:
+            stream.close()
+
+    if args.dry_run or args.verbose:
+        for action in summary.actions:
+            print(action)
+    print(summary.summary_line(), file=sys.stderr)
+    return 0
+
+
 def _run_zep(args: argparse.Namespace) -> int:
     connector: Connector = ZepConnector()
     stream, owned = _open_stream(args.input)
@@ -327,6 +361,34 @@ def build_parser() -> argparse.ArgumentParser:
     )
     mem.set_defaults(func=_run_mem0)
 
+    qd = sub.add_parser(
+        "qdrant",
+        help="Embed documents and upsert into Qdrant (idempotent on canonical id).",
+    )
+    qd.add_argument(
+        "--input",
+        "-i",
+        default=None,
+        help="JSONL file to read (default: stdin). '-' also means stdin.",
+    )
+    qd.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print what would be sent without embedding or calling the API.",
+    )
+    qd.add_argument(
+        "--strict",
+        action="store_true",
+        help="Fail on a malformed line instead of skipping it.",
+    )
+    qd.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Print per-record actions on a live push too.",
+    )
+    qd.set_defaults(func=_run_qdrant)
+
     zep = sub.add_parser(
         "zep",
         help="Upsert documents into Zep (idempotent by graph resync).",
diff --git a/src/rac_connectors/embedding.py b/src/rac_connectors/embedding.py
new file mode 100644
index 0000000..43307db
--- /dev/null
+++ b/src/rac_connectors/embedding.py
@@ -0,0 +1,94 @@
+"""External embedding seam for vector-store connectors (ADR-009).
+
+A vector database stores vectors; it does not produce them. The memory/RAG
+backends RAC already ships (Supermemory, Mem0, Zep) embed **server-side**, so
+their connectors stay model-free (rac-core ADR-002, ADR-066). A bare vector store
+(e.g. Qdrant) cannot — it needs vectors supplied. To keep RAC AI-optional and
+free of bundled models, a vector-store connector embeds by calling a **configured
+external service** over its OpenAI-compatible ``/embeddings`` endpoint. The model
+name and credentials live in that service (a LiteLLM gateway is the reference
+deployment, mirroring the grounding benchmark's ``*_BASE_URL`` pattern), never
+here. This module is the small, provider-neutral seam connectors depend on; the
+test-suite drives a fake, so CI never makes a network call.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+from typing import Protocol, runtime_checkable
+
+BASE_URL_ENV = "RAC_EMBED_BASE_URL"
+API_KEY_ENV = "RAC_EMBED_API_KEY"
+MODEL_ENV = "RAC_EMBED_MODEL"
+
+
+class MissingEmbeddingConfigError(RuntimeError):
+    """No external embedding endpoint/model was configured in the environment."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            f"set {BASE_URL_ENV} and {MODEL_ENV} (and {API_KEY_ENV} if the "
+            "endpoint requires auth) to embed via an external service"
+        )
+
+
+@runtime_checkable
+class Embedder(Protocol):
+    """Turn a batch of texts into vectors, order-preserving.
+
+    One method, so a connector depends only on this Protocol and the test-suite
+    drives a deterministic fake. The returned list has one vector per input text,
+    in the same order.
+    """
+
+    def embed(self, texts: list[str]) -> list[list[float]]: ...
+
+
+class ExternalEmbedder:
+    """Adapter over an OpenAI-compatible ``/embeddings`` endpoint.
+
+    Works with any gateway that speaks the OpenAI embeddings shape — a LiteLLM
+    proxy is the reference deployment, but OpenAI, Ollama, or any compatible
+    endpoint works the same way. Uses only the standard library, so the package
+    gains no dependency; the model and credentials live in the endpoint, not here.
+    """
+
+    def __init__(
+        self, *, base_url: str, model: str, api_key: str | None = None
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._model = model
+        self._api_key = api_key
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        if not texts:
+            return []
+        body = json.dumps({"model": self._model, "input": texts}).encode("utf-8")
+        request = urllib.request.Request(
+            f"{self._base_url}/embeddings", data=body, method="POST"
+        )
+        request.add_header("Content-Type", "application/json")
+        if self._api_key:
+            request.add_header("Authorization", f"Bearer {self._api_key}")
+        with urllib.request.urlopen(request) as response:  # pragma: no cover - network
+            payload = json.load(response)
+        # OpenAI-compatible: {"data": [{"embedding": [...]}, ...]}, input order.
+        return [item["embedding"] for item in payload["data"]]
+
+
+def embedder_from_env() -> ExternalEmbedder:
+    """Build the external embedder from the environment.
+
+    Reads ``RAC_EMBED_BASE_URL`` and ``RAC_EMBED_MODEL`` (and the optional
+    ``RAC_EMBED_API_KEY``). Raises :class:`MissingEmbeddingConfigError` if the
+    endpoint or model is unset, so a live push fails fast with a clear message.
+    """
+    base_url = os.environ.get(BASE_URL_ENV)
+    model = os.environ.get(MODEL_ENV)
+    if not (base_url and model):
+        raise MissingEmbeddingConfigError()
+    return ExternalEmbedder(
+        base_url=base_url, model=model, api_key=os.environ.get(API_KEY_ENV)
+    )
diff --git a/src/rac_connectors/qdrant/__init__.py b/src/rac_connectors/qdrant/__init__.py
new file mode 100644
index 0000000..0be7e60
--- /dev/null
+++ b/src/rac_connectors/qdrant/__init__.py
@@ -0,0 +1,21 @@
+"""Qdrant backend module for rac-connectors."""
+
+from __future__ import annotations
+
+from .client import (
+    MissingCredentialsError,
+    QdrantClient,
+    SdkQdrantClient,
+    client_from_env,
+)
+from .connector import BACKEND, DEFAULT_COLLECTION, QdrantConnector
+
+__all__ = [
+    "BACKEND",
+    "DEFAULT_COLLECTION",
+    "MissingCredentialsError",
+    "QdrantClient",
+    "QdrantConnector",
+    "SdkQdrantClient",
+    "client_from_env",
+]
diff --git a/src/rac_connectors/qdrant/client.py b/src/rac_connectors/qdrant/client.py
new file mode 100644
index 0000000..05b2d80
--- /dev/null
+++ b/src/rac_connectors/qdrant/client.py
@@ -0,0 +1,111 @@
+"""The thin client seam the Qdrant connector upserts through.
+
+The connector depends only on :class:`QdrantClient` (a Protocol), so the
+test-suite drives an in-memory fake and CI never touches a real server.
+:class:`SdkQdrantClient` is the real adapter over the official ``qdrant-client``,
+imported lazily so the package installs and tests run without it.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Protocol, runtime_checkable
+
+URL_ENV = "QDRANT_URL"
+API_KEY_ENV = "QDRANT_API_KEY"
+
+
+class MissingCredentialsError(RuntimeError):
+    """No Qdrant connection details were found in the environment."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            f"set {URL_ENV} (and {API_KEY_ENV} if the server requires auth) "
+            "in the environment (never hard-code credentials)"
+        )
+
+
+@runtime_checkable
+class QdrantClient(Protocol):
+    """What the connector needs from a Qdrant client.
+
+    Two operations: ensure a collection exists with the right vector size, and
+    upsert one point. ``upsert`` must be idempotent on ``point_id`` so re-running
+    an export updates rather than duplicates.
+    """
+
+    def ensure_collection(self, *, collection: str, dimension: int) -> None: ...
+
+    def upsert(
+        self,
+        *,
+        collection: str,
+        point_id: str,
+        vector: list[float],
+        payload: dict[str, Any],
+    ) -> None: ...
+
+
+class SdkQdrantClient:
+    """Adapter over the official ``qdrant-client`` (lazy import).
+
+    Lazily constructs the client so importing this module never requires the
+    package; the import error only surfaces on a live push without the ``qdrant``
+    extra installed. Collections are created on first use with cosine distance.
+    """
+
+    def __init__(self, *, url: str | None = None, api_key: str | None = None) -> None:
+        self._url = url or os.environ.get(URL_ENV)
+        self._api_key = api_key or os.environ.get(API_KEY_ENV)
+        if not self._url:
+            raise MissingCredentialsError()
+        self._client: Any = None
+        self._ensured: set[str] = set()
+
+    def _ensure_client(self) -> Any:
+        if self._client is None:
+            try:
+                from qdrant_client import QdrantClient as _SdkClient
+            except ImportError as exc:  # pragma: no cover - exercised via message
+                raise RuntimeError(
+                    "the 'qdrant-client' package is not installed; "
+                    "install the connector's 'qdrant' extra"
+                ) from exc
+            self._client = _SdkClient(url=self._url, api_key=self._api_key)
+        return self._client
+
+    def ensure_collection(  # pragma: no cover - network
+        self, *, collection: str, dimension: int
+    ) -> None:
+        if collection in self._ensured:
+            return
+        client = self._ensure_client()
+        from qdrant_client.models import Distance, VectorParams
+
+        if not client.collection_exists(collection):
+            client.create_collection(
+                collection_name=collection,
+                vectors_config=VectorParams(size=dimension, distance=Distance.COSINE),
+            )
+        self._ensured.add(collection)
+
+    def upsert(  # pragma: no cover - network
+        self,
+        *,
+        collection: str,
+        point_id: str,
+        vector: list[float],
+        payload: dict[str, Any],
+    ) -> None:
+        client = self._ensure_client()
+        from qdrant_client.models import PointStruct
+
+        client.upsert(
+            collection_name=collection,
+            points=[PointStruct(id=point_id, vector=vector, payload=payload)],
+        )
+
+
+def client_from_env() -> SdkQdrantClient:
+    """Build the real client from environment variables (``QDRANT_URL`` etc.)."""
+    return SdkQdrantClient()
diff --git a/src/rac_connectors/qdrant/connector.py b/src/rac_connectors/qdrant/connector.py
new file mode 100644
index 0000000..fc08be9
--- /dev/null
+++ b/src/rac_connectors/qdrant/connector.py
@@ -0,0 +1,113 @@
+"""The Qdrant connector — a documents backend that embeds via an external service.
+
+A one-way, outbound push of the ``rac export --documents`` stream into Qdrant.
+Unlike the server-side-embedding backends (Supermemory, Mem0, Zep), Qdrant stores
+vectors but does not produce them, so the connector embeds each record's text
+through an external :class:`~rac_connectors.embedding.Embedder` before upserting
+(ADR-009). The point id is derived deterministically from the canonical ``rac_id``
+(a UUID5), so re-exporting upserts in place rather than duplicating. Embeddings
+live in the configured external endpoint, never in the engine (rac-core ADR-002,
+ADR-066).
+"""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import Iterable
+from typing import Any
+
+from ..base import PushSummary
+from ..embedding import Embedder
+from ..records import Record
+from .client import QdrantClient
+
+BACKEND = "qdrant"
+# A corpus without a source still needs a collection; this is the fallback.
+DEFAULT_COLLECTION = "lore"
+# A fixed namespace so a canonical rac_id always maps to the same point id; the
+# upsert is then idempotent on that id. (RFC-4122 URL namespace.)
+_ID_NAMESPACE = uuid.UUID("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
+
+
+class QdrantConnector:
+    """Push ``--documents`` records into Qdrant, idempotent on the canonical id."""
+
+    name = BACKEND
+
+    def __init__(
+        self,
+        client: QdrantClient | None = None,
+        embedder: Embedder | None = None,
+    ) -> None:
+        # Both are optional so a dry run needs no credentials, SDK, or endpoint.
+        self._client = client
+        self._embedder = embedder
+
+    def _collection_for(self, record: Record) -> str:
+        return record.source or DEFAULT_COLLECTION
+
+    def _point_id(self, record: Record) -> str:
+        return str(uuid.uuid5(_ID_NAMESPACE, record.id))
+
+    def _payload_for(self, record: Record) -> dict[str, Any]:
+        """Payload stored alongside the vector.
+
+        ``rac_id`` carries the canonical handle for the verify-in-Lore loop;
+        ``type``/``status``/``title`` ride along so a reader can filter retired or
+        superseded items, and ``text`` is kept so a hit need not round-trip for
+        the body before verifying in Lore.
+        """
+        payload = dict(record.metadata)
+        payload.update(
+            {
+                "rac_id": record.id,
+                "type": record.type,
+                "status": record.status,
+                "title": record.title,
+                "text": record.text,
+            }
+        )
+        return payload
+
+    def push(self, records: Iterable[Record], *, dry_run: bool = False) -> PushSummary:
+        summary = PushSummary(backend=self.name, dry_run=dry_run)
+        ensured: set[str] = set()
+        for record in records:
+            collection = self._collection_for(record)
+            if dry_run:
+                summary.record_push(
+                    record.id,
+                    f"collection={collection} type={record.type} "
+                    f"status={record.status} ({len(record.text)} chars)",
+                )
+                continue
+            client = self._require_client()
+            embedder = self._require_embedder()
+            vector = embedder.embed([record.text])[0]
+            # Create the collection on first use with the embedder's dimension.
+            if collection not in ensured:
+                client.ensure_collection(collection=collection, dimension=len(vector))
+                ensured.add(collection)
+            client.upsert(
+                collection=collection,
+                point_id=self._point_id(record),
+                vector=vector,
+                payload=self._payload_for(record),
+            )
+            summary.record_push(record.id, f"collection={collection} dim={len(vector)}")
+        return summary
+
+    def _require_client(self) -> QdrantClient:
+        if self._client is None:
+            raise RuntimeError(
+                "a QdrantClient is required for a live push; "
+                "pass one or use dry_run=True"
+            )
+        return self._client
+
+    def _require_embedder(self) -> Embedder:
+        if self._embedder is None:
+            raise RuntimeError(
+                "an Embedder is required for a live push; pass one or use dry_run=True"
+            )
+        return self._embedder
diff --git a/tests/test_cli_qdrant.py b/tests/test_cli_qdrant.py
new file mode 100644
index 0000000..41aab59
--- /dev/null
+++ b/tests/test_cli_qdrant.py
@@ -0,0 +1,48 @@
+"""End-to-end CLI behaviour for the `rac-connect qdrant` subcommand."""
+
+from __future__ import annotations
+
+import io
+
+from rac_connectors import cli
+
+
+def _line(record_id: str = "RAC-1") -> str:
+    return (
+        f'{{"schema_version":"1","id":"{record_id}","type":"decision",'
+        f'"status":"Accepted","title":"t","text":"body",'
+        f'"metadata":{{"source":"rac"}}}}'
+    )
+
+
+def test_dry_run_prints_actions_and_makes_no_call(monkeypatch, capsys) -> None:
+    monkeypatch.setattr("sys.stdin", io.StringIO(_line() + "\n"))
+    rc = cli.main(["qdrant", "--dry-run"])
+    assert rc == 0
+    out = capsys.readouterr()
+    assert "push RAC-1" in out.out
+    assert "collection=rac" in out.out
+    assert "1 pushed, 0 skipped" in out.err
+
+
+def test_malformed_line_skipped_by_default(monkeypatch, capsys) -> None:
+    stream = _line("RAC-1") + "\n" + "garbage{\n" + _line("RAC-2") + "\n"
+    monkeypatch.setattr("sys.stdin", io.StringIO(stream))
+    rc = cli.main(["qdrant", "--dry-run"])
+    assert rc == 0
+    assert "2 pushed, 1 skipped" in capsys.readouterr().err
+
+
+def test_strict_mode_fails_on_malformed_line(monkeypatch, capsys) -> None:
+    monkeypatch.setattr("sys.stdin", io.StringIO(_line() + "\n" + "garbage{\n"))
+    rc = cli.main(["qdrant", "--dry-run", "--strict"])
+    assert rc == 1
+    assert "error:" in capsys.readouterr().err
+
+
+def test_live_push_without_credentials_errors(monkeypatch, capsys) -> None:
+    monkeypatch.delenv("QDRANT_URL", raising=False)
+    monkeypatch.setattr("sys.stdin", io.StringIO(_line() + "\n"))
+    rc = cli.main(["qdrant"])
+    assert rc == 2
+    assert "QDRANT_URL" in capsys.readouterr().err
diff --git a/tests/test_embedding.py b/tests/test_embedding.py
new file mode 100644
index 0000000..6d00ae8
--- /dev/null
+++ b/tests/test_embedding.py
@@ -0,0 +1,64 @@
+"""The external embedding seam: env config + OpenAI-compatible response parsing."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from rac_connectors.embedding import (
+    ExternalEmbedder,
+    MissingEmbeddingConfigError,
+    embedder_from_env,
+)
+
+
+def test_embedder_from_env_requires_base_url_and_model(monkeypatch) -> None:
+    monkeypatch.delenv("RAC_EMBED_BASE_URL", raising=False)
+    monkeypatch.delenv("RAC_EMBED_MODEL", raising=False)
+    with pytest.raises(MissingEmbeddingConfigError):
+        embedder_from_env()
+
+
+def test_embedder_from_env_builds_when_configured(monkeypatch) -> None:
+    monkeypatch.setenv("RAC_EMBED_BASE_URL", "https://litellm.example/v1")
+    monkeypatch.setenv("RAC_EMBED_MODEL", "text-embedding-3-small")
+    monkeypatch.delenv("RAC_EMBED_API_KEY", raising=False)
+    assert isinstance(embedder_from_env(), ExternalEmbedder)
+
+
+def test_embed_posts_openai_shape_and_parses_vectors(monkeypatch) -> None:
+    captured: dict[str, object] = {}
+
+    class _Resp:
+        def __enter__(self) -> _Resp:
+            return self
+
+        def __exit__(self, *exc: object) -> bool:
+            return False
+
+        def read(self) -> bytes:
+            return json.dumps(
+                {"data": [{"embedding": [0.1, 0.2]}, {"embedding": [0.3, 0.4]}]}
+            ).encode("utf-8")
+
+    def fake_urlopen(request):  # type: ignore[no-untyped-def]
+        captured["url"] = request.full_url
+        captured["auth"] = request.get_header("Authorization")
+        captured["body"] = json.loads(request.data)
+        return _Resp()
+
+    monkeypatch.setattr("urllib.request.urlopen", fake_urlopen)
+    embedder = ExternalEmbedder(
+        base_url="https://litellm.example/v1", model="m", api_key="k"
+    )
+    vectors = embedder.embed(["a", "bb"])
+
+    assert vectors == [[0.1, 0.2], [0.3, 0.4]]
+    assert str(captured["url"]).endswith("/embeddings")
+    assert captured["auth"] == "Bearer k"
+    assert captured["body"] == {"model": "m", "input": ["a", "bb"]}
+
+
+def test_embed_empty_returns_empty_without_a_call() -> None:
+    assert ExternalEmbedder(base_url="https://x/v1", model="m").embed([]) == []
diff --git a/tests/test_qdrant.py b/tests/test_qdrant.py
new file mode 100644
index 0000000..db04210
--- /dev/null
+++ b/tests/test_qdrant.py
@@ -0,0 +1,139 @@
+"""The Qdrant connector: record->point mapping, idempotent upsert, dry-run."""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any
+
+import pytest
+
+from rac_connectors.qdrant import DEFAULT_COLLECTION, QdrantConnector
+from rac_connectors.qdrant.connector import _ID_NAMESPACE
+from rac_connectors.records import Record
+
+
+class FakeEmbedder:
+    """Deterministic 3-dim embedder; records the texts it was asked to embed."""
+
+    def __init__(self) -> None:
+        self.texts: list[str] = []
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        self.texts.extend(texts)
+        return [[float(len(text)), 1.0, 0.0] for text in texts]
+
+
+class FakeQdrantClient:
+    """In-memory Qdrant: upsert by point id so a re-push overwrites in place."""
+
+    def __init__(self) -> None:
+        self.collections: dict[str, int] = {}
+        self.ensure_calls = 0
+        self.upserts: list[dict[str, Any]] = []
+        self.points: dict[tuple[str, str], dict[str, Any]] = {}
+
+    def ensure_collection(self, *, collection: str, dimension: int) -> None:
+        self.ensure_calls += 1
+        self.collections[collection] = dimension
+
+    def upsert(
+        self,
+        *,
+        collection: str,
+        point_id: str,
+        vector: list[float],
+        payload: dict[str, Any],
+    ) -> None:
+        call = {
+            "collection": collection,
+            "point_id": point_id,
+            "vector": vector,
+            "payload": payload,
+        }
+        self.upserts.append(call)
+        self.points[(collection, point_id)] = call  # upsert by canonical id
+
+
+def _record(**overrides: Any) -> Record:
+    base = {
+        "id": "RAC-ABC",
+        "type": "decision",
+        "status": "Accepted",
+        "title": "ADR-001: Example",
+        "text": "## Context\n\nbody",
+        "metadata": {"path": "rac/decisions/adr-001.md", "source": "rac"},
+    }
+    base.update(overrides)
+    return Record.from_dict(base)
+
+
+def test_record_maps_to_point_with_payload() -> None:
+    client = FakeQdrantClient()
+    embedder = FakeEmbedder()
+    summary = QdrantConnector(client, embedder).push([_record()])
+
+    assert summary.pushed == 1
+    call = client.upserts[0]
+    assert call["collection"] == "rac"  # source maps to the collection
+    assert call["vector"] == [float(len("## Context\n\nbody")), 1.0, 0.0]
+    assert call["payload"]["rac_id"] == "RAC-ABC"  # the verify-in-Lore handle
+    assert call["payload"]["status"] == "Accepted"
+    assert call["payload"]["text"] == "## Context\n\nbody"
+    assert client.collections["rac"] == 3  # dimension comes from the embedder
+
+
+def test_point_id_is_deterministic_uuid5_of_canonical_id() -> None:
+    client = FakeQdrantClient()
+    QdrantConnector(client, FakeEmbedder()).push([_record(id="RAC-1")])
+    assert client.upserts[0]["point_id"] == str(uuid.uuid5(_ID_NAMESPACE, "RAC-1"))
+
+
+def test_repush_is_idempotent_by_point_id() -> None:
+    client = FakeQdrantClient()
+    connector = QdrantConnector(client, FakeEmbedder())
+
+    connector.push([_record(id="RAC-1"), _record(id="RAC-2")])
+    connector.push([_record(id="RAC-1"), _record(id="RAC-2")])
+
+    # Upsert overwrote in place — two distinct points even after a re-push.
+    assert len(client.points) == 2
+
+
+def test_collection_ensured_once_per_collection() -> None:
+    client = FakeQdrantClient()
+    QdrantConnector(client, FakeEmbedder()).push(
+        [_record(id="RAC-1"), _record(id="RAC-2")]
+    )
+    assert client.ensure_calls == 1  # one collection, ensured once, not per record
+    assert client.collections == {"rac": 3}
+
+
+def test_dry_run_makes_no_calls() -> None:
+    client = FakeQdrantClient()
+    embedder = FakeEmbedder()
+    summary = QdrantConnector(client, embedder).push([_record()], dry_run=True)
+
+    assert summary.dry_run is True
+    assert summary.pushed == 1
+    assert client.upserts == [] and embedder.texts == []  # nothing embedded or sent
+
+
+def test_dry_run_needs_no_client_or_embedder() -> None:
+    summary = QdrantConnector().push([_record()], dry_run=True)
+    assert summary.pushed == 1
+
+
+def test_live_push_without_client_errors() -> None:
+    with pytest.raises(RuntimeError, match="QdrantClient is required"):
+        QdrantConnector(embedder=FakeEmbedder()).push([_record()])
+
+
+def test_live_push_without_embedder_errors() -> None:
+    with pytest.raises(RuntimeError, match="Embedder is required"):
+        QdrantConnector(FakeQdrantClient()).push([_record()])
+
+
+def test_missing_source_uses_default_collection() -> None:
+    client = FakeQdrantClient()
+    QdrantConnector(client, FakeEmbedder()).push([_record(metadata={"path": "x.md"})])
+    assert client.upserts[0]["collection"] == DEFAULT_COLLECTION