{"id":50426872,"url":"https://github.com/zilliztech/zilliz-launchpad","last_synced_at":"2026-05-31T11:30:21.277Z","repository":{"id":352601132,"uuid":"1211101074","full_name":"zilliztech/zilliz-launchpad","owner":"zilliztech","description":"From a sample document to a running Milvus / Zilliz Cloud search app in minutes — an AI-guided scaffold delivered as a Agent skill.","archived":false,"fork":false,"pushed_at":"2026-05-18T08:01:50.000Z","size":1475,"stargazers_count":0,"open_issues_count":3,"forks_count":1,"subscribers_count":0,"default_branch":"master","last_synced_at":"2026-05-18T09:39:08.183Z","etag":null,"topics":["ai-agents","claude-code","claude-skill","embeddings","milvus","nextjs","rag","semantic-search","vector-database","vector-search","zilliz","zilliz-cloud"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/zilliztech.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"docs/CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-04-15T04:18:27.000Z","updated_at":"2026-05-18T08:01:50.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/zilliztech/zilliz-launchpad","commit_stats":null,"previous_names":["zilliztech/zilliz-launchpad"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/zilliztech/zilliz-launchpad","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zilliztech%2Fzilliz-launchpad","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zilliztech%2Fzilliz-launchpad/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zilliztech%2Fzilliz-launchpad/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zilliztech%2Fzilliz-launchpad/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/zilliztech","download_url":"https://codeload.github.com/zilliztech/zilliz-launchpad/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/zilliztech%2Fzilliz-launchpad/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33730240,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-05-31T02:00:06.040Z","response_time":95,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai-agents","claude-code","claude-skill","embeddings","milvus","nextjs","rag","semantic-search","vector-database","vector-search","zilliz","zilliz-cloud"],"created_at":"2026-05-31T11:30:20.492Z","updated_at":"2026-05-31T11:30:21.269Z","avatar_url":"https://github.com/zilliztech.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# zilliz-launchpad\n\nFrom a sample document to a production-deployed search app on Milvus / Zilliz Cloud — in minutes.\nAn AI-guided scaffold delivered as an agent skill. \n\nWhether you're new to Milvus or just tired of boilerplate — pick a file, run six steps, ship.\n\n## What you get\n\n| Artifact | Description |\n|----------|-------------|\n| Milvus Collection | Schema auto-designed from your data |\n| Vector + sparse fields | OpenAI / Voyage / Cohere / BYOM (text); CLIP / Voyage multimodal (image) |\n| `plan.md` | Every decision recorded — reviewable and reproducible |\n| Next.js Demo UI | Hybrid search list **or** thumbnail gallery (auto-detected) at `localhost:3000` |\n| `eval_report.md` | recall@10, p50/p95/p99 latency, optional RAG quality metrics |\n| `deploy.json` | Zilliz Cloud deployment record, resumable on rerun |\n\n## Requirements\n\n- **Agent** — Claude Code, Copilot CLI, Gemini CLI, or any [`skills`](https://github.com/superagent-ai/skills)-compatible agent\n- **Python ≥ 3.11** + [`uv`](https://github.com/astral-sh/uv)\n- **Node.js ≥ 18** + pnpm\n- **Docker** (local Standalone) or a Zilliz Cloud account\n- **API key** — OpenAI, Voyage, Cohere, or Zilliz BYOM\n- **Optional** — [`zilliz` CLI](https://github.com/zilliztech/zilliz-cli) for Cloud auto-discovery and bulk import\n- **Optional** — `ffmpeg` on `PATH` (needed for video-search frame sampling; scene-change sampling shells out to it directly)\n\n## Install\n\nThe launchpad ships as an agent skill. Install it with the [`skills`](https://github.com/superagent-ai/skills) CLI, which discovers skills under `skills/` and symlinks them into your agent's skill directory (Claude Code, Copilot CLI, Gemini CLI, Cursor, OpenCode, Codex):\n\n```bash\nnpx skills add zilliztech/zilliz-launchpad\n```\n\nOnce installed, open your agent in this repo and say something like *\"use zilliz-launchpad to index this file\"* — the skill drives the six phases end-to-end (stopping at Phase 4 by default; Phases 5 and 6 kick in when you ask), installing Python deps, bringing up Milvus, and prompting for any missing API keys as it goes.\n\n### Install options\n\n```bash\n# Install to a specific agent\nnpx skills add zilliztech/zilliz-launchpad -a claude-code\n\n# Install globally (available across all projects)\nnpx skills add zilliztech/zilliz-launchpad -g\n\n# Install to all detected agents\nnpx skills add zilliztech/zilliz-launchpad --all\n\n# List available skills before installing\nnpx skills add zilliztech/zilliz-launchpad --list\n```\n\nOther agent flags include `-a copilot-cli`, `-a gemini-cli`, `-a cursor`, `-a opencode`, and `-a codex`.\n\n### MCP install path\n\nFor non-skill-aware hosts (Cursor, Claude Desktop, generic MCP clients), the launchpad\nalso ships an MCP server that exposes the same six phases as MCP tools. Install the\n`mcp` extra and launch the stdio server:\n\n```bash\nuv sync --extra mcp\nuv run python -m launchpad_mcp.server\n```\n\nSee [`mcp/README.md`](mcp/README.md) for the full tool catalog, the structured error\nenvelope, and a host-registration snippet.\n\n### Preflight (optional)\n\nThe skill drives these on demand, but you can do them ahead of time to skip a few conversational round-trips:\n\n```bash\n# Install Python deps\nuv sync\n\n# Bring up local Milvus Standalone (skip if using Zilliz Cloud)\n./skills/zilliz-launchpad/scripts/start_milvus.sh up\n\n# Export at least one embedding key\nexport OPENAI_API_KEY=\u003cyour-key\u003e\n```\n\nIf you plan to drive the CLI directly without an agent, run all three — the Walkthrough below assumes they're done.\n\n## Walkthrough — the six phases\n\nThe launchpad is organized as six CLI subcommands. Each writes a single artifact to `skills/zilliz-launchpad/scripts/runs/\u003cutc-timestamp\u003e/`. You can rerun any phase; nothing is destructive until Phase 4 touches Milvus, and Phase 6 is gated behind an explicit `--confirm` before it creates any Cloud resources.\n\n```\ncollect ──▶ configure ──▶ plan ──▶ execute ──▶ evaluate ──▶ deploy\n                                       │           │           │\n                                       │           │           └─ Zilliz Cloud + deploy.json\n                                       │           └─ eval_report.{json,md}\n                                       └─ Milvus collection + demo UI\n```\n\nWe'll use the bundled `movies` sample (20 short fictional plot summaries) throughout.\n\n---\n\n### Phase 1 — Collect: analyze your data\n\nLooks at your file, infers field types, picks a candidate primary key and text field, and writes `collect.json`.\n\n```bash\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py collect --sample movies\n# or: --input path/to/your.jsonl\n# or: --input path/to/your.pdf      # one record per page (requires `.[documents]` extra)\n# or: --input path/to/notes.md      # whole file; add --split-markdown-headings for `## ` sections\n# or: --input ./docs/               # directory (recursive) — mixes .jsonl/.pdf/.md/.csv/.txt\n# or: --input 'docs/*.pdf'          # shell glob — quote it so the shell doesn't expand it first\n```\n\nDirectory or glob inputs produce a `source_files[]` array in `collect.json` (one entry per file) and a union schema across files. A field name appearing in only some files is marked `nullable: true`; the same field name with different JSON types in different files raises `input_schema_conflict` and refuses to write `collect.json`.\n\nOutput (`collect.json`, abbreviated):\n\n```json\n{\n  \"data_shape\": \"jsonl\",\n  \"record_count_estimate\": 20,\n  \"fields\": [\n    { \"name\": \"id\",    \"type\": \"string\", \"avg_length\": 4,   \"sample_value\": \"m001\" },\n    { \"name\": \"title\", \"type\": \"string\", \"avg_length\": 18,  \"sample_value\": \"The Quantum Gardener\" },\n    { \"name\": \"body\",  \"type\": \"string\", \"avg_length\": 126, \"sample_value\": \"An astrophysicist...\" },\n    { \"name\": \"year\",  \"type\": \"int\",    \"sample_value\": 2023 },\n    { \"name\": \"genre\", \"type\": \"string\", \"sample_value\": \"sci-fi\" }\n  ]\n}\n```\n\n\u003e **For Milvus veterans:** this is where you'd normally hand-write a `CollectionSchema`. Skip it.\n\n\u003e **Image search?** Point `--input` at a directory of images (`.jpg/.png/.webp/.gif`):\n\u003e ```bash\n\u003e uv run python skills/zilliz-launchpad/scripts/zilliz_ops.py collect --input ./photos/\n\u003e uv run python skills/zilliz-launchpad/scripts/zilliz_ops.py configure \\\n\u003e     --use-case image-search --dataset-size 64000 --deployment local-standalone\n\u003e ```\n\u003e Phase 1 walks the directory, reads EXIF, encodes a thumbnail per image. Phase 3 then picks `clip-local` (open-source ViT-B/32, runs on CPU/MPS/CUDA, no API key) by default — install the optional extra first: `uv pip install -e '.[multimodal]'`. The Next.js UI auto-switches to a thumbnail gallery. See [issue #14](https://github.com/zilliztech/zilliz-launchpad/issues/14) for the MVP scope.\n\u003e\n\u003e **Search by example (image → image).** After Phase 4 Execute builds the collection you can query with another image instead of a text phrase. In the demo UI (`pnpm dev` from `scripts/ui/`) click **Search by image…** next to the text box — or drop an image anywhere on the page — to find visually similar images in your collection. Uploads are capped at 10 MB per request. For a CLI smoke:\n\u003e ```bash\n\u003e uv run python skills/zilliz-launchpad/scripts/zilliz_ops.py evaluate \\\n\u003e     --query-image ./query/my_dog.jpg\n\u003e ```\n\u003e This prints the top-10 ranked primary keys with scores and is the fastest way to confirm image-to-image is wired. For a labelled eval, mix image-to-image rows into your qrels file (one row per line):\n\u003e ```json\n\u003e {\"query_image_path\": \"query/sunset.jpg\", \"expected_image_ids\": [\"photos/sky1.jpg\", \"photos/beach2.jpg\"]}\n\u003e ```\n\u003e and pass the file to `evaluate --qrels path/to/qrels.jsonl` to get recall / MRR / NDCG against your ground truth. Queries against a Voyage-multimodal-backed collection (`embedding_preference: voyage-multimodal-3`) call the Voyage API per query and bill to `VOYAGE_API_KEY`; CLIP-local stays free. See [issue #15](https://github.com/zilliztech/zilliz-launchpad/issues/15).\n\u003e\n\u003e **Video search?** Point `--input` at a directory of `.mp4 / .mov / .mkv / .webm` clips:\n\u003e ```bash\n\u003e uv run python skills/zilliz-launchpad/scripts/zilliz_ops.py collect --input ./clips/\n\u003e uv run python skills/zilliz-launchpad/scripts/zilliz_ops.py configure \\\n\u003e     --use-case video-search --dataset-size 25 --deployment local-standalone\n\u003e ```\n\u003e Phase 1 samples a frame every 2 seconds (default) using PyAV, capped at 600 frames per video, and writes JPEGs under `\u003crun-dir\u003e/frames/`. Phase 3 reuses the same CLIP path image-search uses (or `voyage-multimodal-3` on override) and adds two scalar fields (`video_path`, `t_seconds`) so the UI can deep-link playback. Phase 4 fans out per video, embedding frames in batches with resumable per-video tracking (`processed_videos[]`). The demo UI renders each unique video as a card with the top-scoring frame as the primary thumbnail plus clustered secondary frames under it; clicking mounts an inline `\u003cvideo\u003e` element seeked to the matched timestamp. Sidecar static-serves videos under `/videos/…`; set `LAUNCHPAD_VIDEO_STATIC_ROOT` to point at your source tree if it lives outside the run-directory parent. Tune sampling density with `--frame-interval-seconds`, `--max-frames-per-video`, and `--sampling-strategy {every_n_seconds, scene_change}` (scene-change needs `ffmpeg` on `PATH`). Evaluation reports both `recall@k (frame)` and `recall@k (video)` so you can see whether the right moment (frame) or the right clip (video) is being retrieved. See [issue #16](https://github.com/zilliztech/zilliz-launchpad/issues/16). Voyage multimodal ingest bills per-frame; for videos default to CLIP-local unless you explicitly opt in. The sidecar upload cap remains 10 MB per request (inherited from image-search).\n\n---\n\n### Phase 2 — Configure: capture your intent\n\nThree knobs decide everything downstream: **use case**, **dataset size**, **deployment target**.\n\n```bash\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py configure \\\n    --use-case rag \\\n    --dataset-size 20 \\\n    --deployment local-standalone\n```\n\n| Flag | Common values |\n| --- | --- |\n| `--use-case` | `rag`, `semantic-search`, `hybrid-search`, `recommendation`, `image-search`, `video-search` |\n| `--dataset-size` | row-count estimate, drives index choice |\n| `--deployment` | `local-standalone`, `zilliz-serverless`, `zilliz-dedicated`, `zilliz-byoc` |\n\nOutput (`configure.json`): a normalized requirement profile used by the downstream phases.\n\n---\n\n### Phase 3 — Plan: deterministic decisions, no LLM\n\nReads `collect.json` + `configure.json` and writes both a machine plan (`plan.json`) and a human-readable explanation (`plan.md`).\n\n```bash\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py plan\n```\n\nExample `plan.md`:\n\n```markdown\n# Launchpad Plan\n\n- Collection: `launchpad_collection`\n- Target URI: `http://localhost:19530`\n- Deployment: `local-standalone`\n\n## Schema\n- Primary key: `id`\n- Text field: `body`\n- Vector field: `embedding` (dim 1536)\n- Sparse field: `sparse`\n- Extra fields: title, year, genre\n\n## Embedding\n- Provider: `openai`\n- Model: `text-embedding-3-small`\n- Dim: 1536\n\n## Index\n- Type: HNSW   Metric: COSINE\n- Params: { \"M\": 16, \"efConstruction\": 200 }\n\n## Rationale\n- Dataset size 20 → HNSW with M=16, ef=200\n- Use case 'rag' + hybrid preference 'auto' → sparse=True\n- Embedding provider 'openai' model 'text-embedding-3-small' (dim 1536)\n```\n\nRead the rationale, tweak `configure.json` if you disagree, rerun `plan`. Nothing has touched Milvus yet.\n\n---\n\n### Phase 4 — Execute: create the collection, ingest, search\n\n```bash\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py execute --sample movies\n# → connecting to http://localhost:19530\n# → creating collection 'launchpad_collection' (HNSW, COSINE, dim=1536)\n# → embedding 20 rows with openai/text-embedding-3-small\n# → ingested 20 / 20\n# → smoke test: query \"movie about parallel universes\"\n# → ✓ Top-1: m001 'The Quantum Gardener' score=0.87\n\n# Ingest a whole folder of weekly exports — `execute` streams files in\n# lexicographic order. If the process is killed mid-batch, re-running with\n# the same --run-dir resumes from the next file via execute.json.processed_files[]:\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py execute \\\n    --run-dir runs/2026-05-20-collect --input ./weekly_exports/\n```\n\nWhat it does:\n\n1. Connects to the URI from `plan.json` (local Milvus or Zilliz Cloud)\n2. Creates the collection + index per the plan (idempotent: skips if it matches; errors with `schema_conflict` if not)\n3. Embeds and upserts your data (client-side for ≤100k rows, `zilliz import` for larger corpora when the CLI is installed)\n4. Runs a smoke query and prints the top-1 result\n\n---\n\n### Demo UI\n\n```bash\ncd skills/zilliz-launchpad/scripts/ui\npnpm install\npnpm dev\n# → http://localhost:3000\n```\n\nA minimal Next.js app that calls a local `/api/search` route, which in turn hits your Milvus collection. Uses the latest run directory automatically. Hot-reload friendly — restyle it however you like.\n\n---\n\n### Phase 5 — Evaluate: score retrieval, latency, RAG quality\n\nRuns a query set against the live collection and writes `eval_report.{json,md}`. Three query-set tiers — pick whichever matches the labels you have:\n\n```bash\n# Derived smoke eval: no labels required, samples 25 docs from your corpus\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py evaluate\n\n# Labelled eval: recall@10, MRR@10, NDCG@10\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py evaluate --qrels qrels.jsonl\n\n# Opt-in RAG quality via ragas (needs a generator-model API key)\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py evaluate \\\n    --qrels qrels.jsonl --judge-llm openai:gpt-4o-mini\n```\n\nExample `eval_report.md`:\n\n```markdown\n# Evaluation Report — 2026-04-23T10-15-02Z-execute\n\n- Query count: 25\n- Derived query set: **true**\n\n## Decision table\n\n| variant | recall@10 | p95 (ms) | faithfulness | cost/query |\n| --- | --- | --- | --- | --- |\n| base | 0.920 | 42.7 | — | — |\n\n\u003e Note: queries were derived from the corpus...\n```\n\n**Comparison mode** — re-run the same query set against alternative plan variants (swap embedding model, index params, hybrid on/off, reranker on/off) and get a decision table. Capped at 6 variants by default:\n\n```bash\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py evaluate \\\n    --qrels qrels.jsonl --compare variants.yaml\n```\n\n```yaml\n# variants.yaml\nvariants:\n  - name: small-m\n    overrides: { index: { params: { M: 8 } } }\n  - name: voyage\n    overrides: { embedding: { model: voyage-3 } }\n  - name: no-hybrid\n    overrides: { hybrid: false }\n```\n\nSee [`skills/zilliz-launchpad/references/knowledge/evaluation_guide.md`](skills/zilliz-launchpad/references/knowledge/evaluation_guide.md) for the full metric contract.\n\n---\n\n### Phase 6 — Deploy: promote to Zilliz Cloud\n\nRecreates the plan's collection + index on a Zilliz Cloud cluster, ingests data (bulk import above the plan's threshold, client-side below), and writes `deploy.json` with observability pointers and a resumable state machine. Snapshots after every transition, so a rerun picks up where a failure left off.\n\n```bash\n# Target an existing cluster\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py deploy --cluster-id \u003cid\u003e\n\n# Or provision a new one — --confirm is required because this bills real money\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py deploy --create --confirm\n```\n\nWhat it does:\n\n1. **Preflight** — checks the `zilliz` CLI is installed + authenticated (`zilliz auth whoami`), and when targeting an existing cluster, verifies it's `RUNNING`\n2. **Provision** (with `--create`) — calls `zilliz cluster create` with plan/region from `configure.json`, polls `zilliz cluster describe` with exponential backoff until `RUNNING`\n3. **Collection + index** — reuses Phase 4's idempotent `create_collection` + `create_index`; surfaces `schema_conflict` if an incompatible collection already exists on the cluster\n4. **Ingest** — routes through `zilliz import create` for corpora above the plan's `bulk_import_threshold` (default 100k), falls back to client-side upsert if bulk fails\n5. **Observability** — records the Grafana dashboard URL (from `cluster describe`) in `deploy.json.observability.grafana_dashboard` and appends a post-ingest snapshot to `observability.json`\n\n`deploy.json` carries the fixed schema the spec guarantees: `cluster_id`, `cluster_uri`, `token_source`, `collection_name`, `ingest_mode`, `ingest_row_count`, `ingest_status`, `observability`, `timestamps`. If Phase 6 stops mid-run (cluster provisioned, ingest failing), a rerun with `--cluster-id \u003cid\u003e` skips the already-ready steps and retries only what's left.\n\n## Example prompts\n\nThe CLI is the seam, but day-to-day you'll talk to the skill in natural language inside your agent. Here are concrete prompts that map cleanly to the six phases — each one shows what the skill runs under the hood.\n\n### 1. First time — just run the bundled sample\n\n\u003e *\"Use zilliz-launchpad with the bundled `movies` sample so I can see the whole flow end-to-end.\"*\n\nSkill runs Phases 1–4 against `sample_data/movies.jsonl` (`--use-case rag --dataset-size 20 --deployment local-standalone`) and starts the demo UI. **Best first invocation** — proves your environment is wired before you point it at real data. Once you've clicked around the UI, ask *\"now run Phase 5 in derived mode\"* for a quick latency+recall smoke.\n\n### 2. RAG over your own JSONL\n\n\u003e *\"I have `~/data/support_tickets.jsonl` (~80k rows, fields: `ticket_id`, `subject`, `body`, `priority`). Index it for RAG on local Milvus.\"*\n\n- `collect --input ~/data/support_tickets.jsonl` — infers fields, picks `body` as the text field\n- `configure --use-case rag --dataset-size 80000 --deployment local-standalone`\n- `plan` — sparse field on by default for RAG\n- `execute` — embed + upsert + smoke query\n\n### 3. Hybrid search over a product catalog\n\n\u003e *\"I want hybrid search over `products.jsonl` — keyword should match SKUs and brand names exactly, semantic should match descriptions.\"*\n\nSkill writes `--use-case hybrid-search` into `configure.json`. Phase 3 produces dense (HNSW) + sparse (BM25) indexes; Phase 4 embeds the description field while keeping SKU/brand as scalar fields you can filter on in the UI. **Useful when you've used sparse before but don't want to wire BM25 + dense by hand.**\n\n### 4. Skip local Milvus, go straight to Zilliz Cloud\n\n\u003e *\"Skip local — set up a serverless cluster on Zilliz Cloud and ingest `corpus.jsonl` (~1.2M rows) into it.\"*\n\nAssumes `zilliz auth login` already done. Skill will:\n\n- Run `zilliz cluster list`, let you pick (or auto-select your most recent)\n- `configure --deployment zilliz-serverless --dataset-size 1200000`\n- Pre-flight cluster state via `zilliz cluster describe`\n- Detect \u003e100k rows and route Phase 4 through `zilliz import create` instead of client-side upsert\n\n### 5. Tweak the plan before touching Milvus\n\n\u003e *\"The current plan picked `text-embedding-3-small`. Switch to Voyage's `voyage-3` and rerun the plan.\"*\n\nSkill edits the embedding section of `configure.json` in the active run dir, reruns `plan`, and diffs the new `plan.md` against the previous one. Phase 3 is deterministic and never touches Milvus, so you can iterate freely until you're happy, then run `execute`.\n\n### 6. Append new data to an existing collection\n\n\u003e *\"I already ran the launchpad on `docs_v1.jsonl` last week. Now I have `docs_v2.jsonl` — append it to the same collection.\"*\n\nSkill runs `execute --append --run-dir \u003cprevious-run-dir\u003e --input docs_v2.jsonl`. The append path reuses `plan.json` (no re-plan), confirms the live collection schema matches, and upserts only the new rows. Results land in a fresh `execute_append.json` artifact so the original `execute.json` stays untouched (and a second append produces `execute_append.2.json`, etc.). If the new file's fields don't match the planned schema, it stops with `schema_conflict` and tells you how to resolve it.\n\n### 7. Recover from `schema_conflict`\n\n\u003e *\"Phase 4 just failed with `schema_conflict`. What do I do?\"*\n\nSkill parses the JSON error envelope on stderr and offers two paths: drop the existing collection (destructive — confirms first), or change `collection_name` in `plan.json` and rerun. **The general pattern**: every CLI error code in [`docs/TROUBLESHOOTING.md`](docs/TROUBLESHOOTING.md) maps to a remediation the skill knows how to drive — so when something goes red, just paste the error back into the conversation.\n\n### 8. Compare embedding models before committing\n\n\u003e *\"I have `qrels.jsonl` with 50 labelled queries. Before I commit to an embedding model, run Phase 5 with `voyage-3` and `text-embedding-3-small` side-by-side.\"*\n\nSkill writes a `variants.yaml` with the two overrides, runs `evaluate --qrels qrels.jsonl --compare variants.yaml`, and shows the resulting decision table (recall@10, p95, faithfulness per variant). **Use this whenever you're about to change a plan axis and want signal, not vibes.**\n\n### 9. Promote the local prototype to Cloud\n\n\u003e *\"The local eval looks good. Promote this run to a new Zilliz Cloud serverless cluster.\"*\n\nSkill confirms the projected cost, runs `deploy --create --confirm`, streams `zilliz cluster describe` progress to stderr while the cluster comes up, and tails `deploy.json` as the state machine advances. If anything fails mid-deploy, a rerun with `deploy --cluster-id \u003cid\u003e` resumes from the last checkpoint — the skill reads `deploy.json` to know which steps are already done.\n\n### 10. Index my photos for text-to-image search\n\n\u003e *\"I have ~5,000 photos in `~/Pictures/library`. Make them searchable by typing — I want to type 'sunset' and see sunsets.\"*\n\nSkill installs the `[multimodal]` extra if it's missing, then runs:\n\n- `collect --input ~/Pictures/library` — walks the directory, reads dimensions / EXIF / capped 256 px thumbnails per image\n- `configure --use-case image-search --dataset-size 5000 --deployment local-standalone` — forces hybrid off, picks `clip-local` (ViT-B/32, 512 dim) by default\n- `plan` — schema is dense-only with `image_path` as the primary key\n- `execute` — downloads CLIP weights once (~150 MB), batches images through the encoder, ingests; the demo UI auto-detects the modality and renders a thumbnail grid instead of a text list\n\nFor Phase 5 add `--judge-llm openai:gpt-4o-mini` to derive captioned eval queries; cached to `derived_image_queries.jsonl` so reruns don't re-spend tokens.\n\n## Going to Zilliz Cloud\n\nThere are two patterns — pick based on whether you want to iterate locally first.\n\n### Pattern A — prototype locally, promote via Phase 6 (recommended)\n\nRun Phases 1–5 against local Standalone, then `deploy` to Cloud once the eval looks good:\n\n```bash\n# Phases 1–4 against local Milvus (--deployment local-standalone)\n# Phase 5 on local to sanity-check recall + latency\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py evaluate --qrels qrels.jsonl\n\n# Phase 6 promotes to Cloud. --create provisions a new cluster; --cluster-id targets existing.\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py deploy --create --confirm\n```\n\nPhase 6 requires the [`zilliz` CLI](https://github.com/zilliztech/zilliz-cli) (≥ 0.3.0) on PATH with `zilliz auth login` done. Cluster plan (Serverless / Standard / Enterprise) and region are taken from `configure.json`.\n\n### Pattern B — target Cloud from the start\n\nSkip local Standalone entirely by setting the Cloud target in Phase 2:\n\n```bash\nuv run python skills/zilliz-launchpad/scripts/zilliz_ops.py configure \\\n    --use-case rag --dataset-size 500000 --deployment zilliz-serverless\n```\n\nWith the `zilliz` CLI on PATH, the launchpad will:\n\n- Discover your clusters (`zilliz cluster list`) and write `cluster_id` into `configure.json`\n- Pre-flight the cluster state (`zilliz cluster describe`) before Phase 4 ingests anything\n- Route ingestion through `zilliz import create` for corpora above the plan's `bulk_import_threshold` (default 100k rows)\n\nWithout the CLI, export `ZILLIZ_TOKEN` directly and Phase 4 falls back to client-side upsert. Phase 6's `--create` path requires the CLI — there's no paste-the-token fallback for cluster provisioning.\n\n## Troubleshooting\n\nSee [`docs/TROUBLESHOOTING.md`](docs/TROUBLESHOOTING.md) for common errors (missing credentials, schema conflicts, Cloud cluster states) and their remediations. Every CLI error is a single-line JSON envelope on stderr — the `code` field maps to a row in that doc.\n\n## License\n\nApache-2.0. Copyright 2026 Zilliz.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fzilliztech%2Fzilliz-launchpad","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fzilliztech%2Fzilliz-launchpad","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fzilliztech%2Fzilliz-launchpad/lists"}