server/GUIDE.md

Copernicus RAG — full Qdrant server setup

Stand-alone guide: from zero to a running Qdrant server carrying all five collections of dmpantiu/copernicus-rag-core, byte-identical to the validated indexes (dense 768-d + sparse BM25 vectors, relinked payloads, payload indexes). No embedding model, no Google/Gemini key, no re-computation involved.

What you get

collection	points	content	key filterable payload fields
copernicus_docs	1,418	L1 dataset cards, all 4 stores	product_id, doc_type, store
marine_docs	29,249	CMEMS PUM/QUID/SQO chunks	product_id, doc_type, chunk_type, section_path
cds_docs	23,341	CDS/ADS/EWDS PUG/ATBD chunks	dataset_ids, store, doc_type, doc_url
eqc_qa	1,274	C3S EQC quality reports	dataset_id, store, doc_type, aspect
publications	430,066	12,411 parsed papers, dataset-linked	doi, paper_id, journal, year, domains, orphan, linked_products, chunk_type

Every collection has named vectors: dense (768-d, cosine, gemini-embedding-2-preview, L2-normalized) and sparse (BM25, IDF modifier) — so keyword search works with no embedding model at all, and hybrid search works if you can embed queries (see below).

1 · Prerequisites

• Docker + docker compose (any recent version).
• Python 3.10+.
• Access to the private HF dataset (ask the owner to add you as a collaborator on dmpantiu/copernicus-rag-core) and a HF access token (huggingface.co → Settings → Access Tokens → read).
• Disk: ~2.5 GB download + ~6 GB Qdrant storage. RAM: 2–4 GB is plenty (payloads are stored on disk).

2 · Get this folder & install deps

export HF_TOKEN=hf_...           # your token
pip install -U huggingface_hub
hf download dmpantiu/copernicus-rag-core --repo-type dataset \
   --include "server/*" --local-dir .
cd server
pip install -r requirements.txt

3 · Start the Qdrant server

docker compose up -d
curl http://localhost:6333/readyz     # -> all shards are ready

Dashboard: http://localhost:6333/dashboard. Data persists in ./qdrant_storage across restarts. To protect the server, uncomment QDRANT__SERVICE__API_KEY in docker-compose.yml first.

4 · Load all five collections

python load_all.py --url http://localhost:6333

What it does: downloads the four indexes/*.tar.gz from HF (≈2.5 GB, cached in the temp dir), untars them, opens each prebuilt index locally and streams the points into your server — vectors, payloads and payload indexes are copied 1:1 from the validated build (50/50 test queries green).

• Timing: the four smaller collections (~55k points) land in minutes; publications (430k points) is limited by the embedded-format reader and takes a few hours on a laptop — run it in tmux/screen or overnight. Practical order: grab the small ones first, then let publications grind:

  python load_all.py --url ... --collections copernicus_docs marine_docs cds_docs eqc_qa
  python load_all.py --url ... --collections publications   # long — tmux it
  

• Resumable / idempotent: re-running skips collections whose point count already matches; --recreate forces a clean re-copy. An interrupted collection is re-copied from scratch on the next run.
• Remote/managed cluster: --url https://<cluster>.cloud.qdrant.io --api-key <key>
• Already downloaded the tarballs? Untar each indexes/qdrant_<name>.tar.gz into <dir>/qdrant_<name>/ and pass --source-dir <dir>.

The script verifies every collection (server count == source count) and aborts loudly on mismatch. Expected final state:

copernicus_docs 1418 · marine_docs 29249 · cds_docs 23341 · eqc_qa 1274 · publications 430066

5 · Query it

Keyword / BM25 (no embedding model needed)

from qdrant_client import QdrantClient, models
from fastembed import SparseTextEmbedding

c = QdrantClient(url="http://localhost:6333")
bm25 = SparseTextEmbedding(model_name="Qdrant/bm25")

def sparse(q):
    r = list(bm25.embed([q]))[0]
    return models.SparseVector(indices=r.indices.tolist(), values=r.values.tolist())

hits = c.query_points("publications", query=sparse("marine heatwave detection SST"),
                      using="sparse", limit=5, with_payload=True)
for h in hits.points:
    print(round(h.score, 2), h.payload["title"][:70])

Dense & hybrid (needs query embeddings)

The corpus vectors are gemini-embedding-2-preview, RETRIEVAL_QUERY task, 768-d, L2-normalized — embed queries the same way:

import numpy as np
from google import genai
from google.genai import types

g = genai.Client(api_key=GEMINI_KEY)
def dense(q):
    r = g.models.embed_content(model="gemini-embedding-2-preview", contents=q,
        config=types.EmbedContentConfig(task_type="RETRIEVAL_QUERY", output_dimensionality=768))
    v = np.array(list(r.embeddings[0].values), dtype=np.float32)
    return (v / np.linalg.norm(v)).tolist()

# hybrid: dense + BM25 fused with RRF, server-side
hits = c.query_points(
    "publications",
    prefetch=[
        models.Prefetch(query=dense(q), using="dense", limit=20),
        models.Prefetch(query=sparse(q), using="sparse", limit=20),
    ],
    query=models.FusionQuery(fusion=models.Fusion.RRF),
    limit=5, with_payload=True)

No Gemini access? Two options: BM25-only (above, surprisingly strong on this corpus), or re-embed the chunks with an open model — REBUILD.md §A is the recipe (chunks/*.jsonl carry the raw text; swap is ~20 lines).

Filters (payload indexes are in place)

# everything linked to ERA5, full-text chunks only
flt = models.Filter(must=[
    models.FieldCondition(key="linked_products",
                          match=models.MatchValue(value="reanalysis-era5-single-levels")),
    models.FieldCondition(key="chunk_type", match=models.MatchValue(value="text")),
])
c.query_points("publications", query=sparse("wind energy assessment"),
               using="sparse", query_filter=flt, limit=5)

# QUID (quality) docs for one CMEMS product
flt = models.Filter(must=[
    models.FieldCondition(key="product_id",
                          match=models.MatchValue(value="GLOBAL_MULTIYEAR_PHY_001_030")),
    models.FieldCondition(key="doc_type", match=models.MatchValue(value="QUID")),
])
c.query_points("marine_docs", query=sparse("assimilated observations"),
               using="sparse", query_filter=flt, limit=5)

6 · Ops notes

• Backups: curl -X POST http://localhost:6333/collections/publications/snapshots (or just stop the container and copy qdrant_storage/).
• Upgrades: bump the image tag in docker-compose.yml; storage is forward-compatible across minor versions.
• Memory: on_disk_payload is enabled; vectors stay in RAM (~1.5 GB total). For tighter RAM add on-disk HNSW/quantization — see Qdrant docs.
• The MCP server (scripts/marine_rag/rag_server.py) is server-first: if a Qdrant server is reachable at QDRANT_URL (default http://localhost:6333) and carries the collection, it uses it — publications queries drop from minutes (embedded) to ~30 ms. It silently falls back to its embedded copies when the server is down; set QDRANT_URL="" to force embedded mode.

7 · Troubleshooting

symptom	fix
401 on download	token lacks read access, or you're not a collaborator on the dataset
load_all.py can't reach server	docker compose ps, curl localhost:6333/readyz; port 6333 busy → change mapping
count MISMATCH abort	re-run (it re-copies the failed collection); check server disk space
slow upserts	expected on spinning disks; use --collections to prioritize what you need first
Apple Silicon	works out of the box (multi-arch image)