opensearch-launchpad — Claude Code skill for OpenSearch search
opensearch-launchpad is a Claude Code skill for planning an OpenSearch search app from sample data to architecture, including index setup, semantic search, and document ingestion.
Apache-2.0 145 installs ★ 63 updated 2026-10-24
npx skills add opensearch-project/opensearch-agent-skills --skill opensearch-launchpad -a claude-codeWhat opensearch-launchpad does
The skill guides a search project through cluster checks, sample-data review, strategy selection, and a deployment target. It presents the proposed architecture before carrying out the setup. For unstructured documents, it uses a preset built around agentic flow, neural_sparse ingestion, and semantic enrichment.
Python scripts handle cluster startup and operations. They require uv; local runs also need Docker, while AWS runs need configured AWS credentials. A local target will not start without Docker. PDF, DOCX, PPTX, and XLSX files are processed with Docling, and preflight-check must come before cluster operations.
What it helps with
- choose a search strategy for JSON or CSV data
- check cluster availability before setup
- inspect a sample of local data
- prepare PDF or DOCX files for search
- plan a local or AWS OpenSearch deployment
Example prompts for the agent
- Plan an OpenSearch search app for the product data in
products.json. - Set up semantic search over these PDFs, starting with a cluster availability check.
- Propose a hybrid search architecture for the records in
catalog.csv.
How to install opensearch-launchpad
1Skills CLI (Vercel)
npx skills add opensearch-project/opensearch-agent-skills --skill opensearch-launchpad -a claude-code2Manually: put the files in place
~/.claude/skills/opensearch-launchpad/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/opensearch-launchpad/
1Skills CLI (Vercel)
npx skills add opensearch-project/opensearch-agent-skills --skill opensearch-launchpad -a codex2Manually: put the files in place
.agents/skills/opensearch-launchpad/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add opensearch-project/opensearch-agent-skills --skill opensearch-launchpad -a cursor2Manually: put the files in place
.cursor/skills/opensearch-launchpad/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install opensearch-project/opensearch-agent-skills skills/opensearch-skills/search/opensearch-launchpad2Manually: put the files in place
.github/skills/opensearch-launchpad/SKILL.md1Skills CLI (Vercel)
npx skills add opensearch-project/opensearch-agent-skills --skill opensearch-launchpad -a gemini-cli2Platform CLI
gemini skills install https://github.com/opensearch-project/opensearch-agent-skills --path skills/opensearch-skills/search/opensearch-launchpadManually: put the files in place
.devin/skills/opensearch-launchpad/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add opensearch-project/opensearch-agent-skills --skill opensearch-launchpad -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about opensearch-launchpad
How do I install opensearch-launchpad in Claude Code?
Run npx skills add opensearch-project/opensearch-agent-skills --skill opensearch-launchpad -a claude-code. The skill file should be at ~/.claude/skills/opensearch-launchpad/SKILL.md.
What does opensearch-launchpad do?
It guides users through planning and setting up an OpenSearch search app, from checking the cluster and reviewing sample data to choosing a search strategy.
What does the skill need to run?
The Python scripts require uv. A local target needs Docker running; an AWS target needs configured AWS credentials.
Source text
SKILL.md · Apache-2.0
---
name: opensearch-launchpad
description: >
Build search applications with OpenSearch from scratch. Use this skill when
the user mentions search app, index setup, search architecture, semantic
search, vector search, hybrid search, BM25, dense vector, sparse vector,
agentic search, RAG, embeddings, KNN, PDF ingestion, document processing,
or any related search topic. Activate even if the user says search quality,
evaluation, nDCG, precision, relevance tuning, or search builder without
mentioning OpenSearch.
compatibility: Requires uv. Target local requires Docker. Target aws requires AWS credentials (no Docker).
metadata:
author: opensearch-project
version: "2.0"
---
# OpenSearch Launchpad
You are an OpenSearch solution architect. You guide users from initial requirements to a running search setup.
## Prerequisites
- `uv` installed (for running Python scripts)
- The skill directory available locally
- **Target `local`:** Docker installed and running
- **Target `aws`:** AWS credentials configured (no Docker needed)
## Optional MCP Servers
```json
{
"mcpServers": {
"ddg-search": {
"command": "uvx",
"args": ["duckduckgo-mcp-server"]
},
"opensearch-mcp-server": {
"command": "uvx",
"args": ["opensearch-mcp-server-py@latest"],
"env": { "FASTMCP_LOG_LEVEL": "ERROR" }
}
}
}
```
- **`ddg-search`** — Search OpenSearch documentation. Use `search(query="site:opensearch.org <your query>")`.
- **`opensearch-mcp-server`** — Direct OpenSearch API access. Handles SigV4 auth for AOS/AOSS transparently.
### opensearch-mcp-server Configuration Variants
For basic auth (local/self-managed):
```json
{
"opensearch-mcp-server": {
"command": "uvx",
"args": ["opensearch-mcp-server-py@latest"],
"env": {
"OPENSEARCH_URL": "<endpoint_url>",
"OPENSEARCH_USERNAME": "<username>",
"OPENSEARCH_PASSWORD": "<password>",
"OPENSEARCH_SSL_VERIFY": "false",
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
```
For Amazon OpenSearch Service (AOS):
```json
{
"opensearch-mcp-server": {
"command": "uvx",
"args": ["opensearch-mcp-server-py@latest"],
"env": {
"OPENSEARCH_URL": "<endpoint_url>",
"AWS_REGION": "<region>",
"AWS_PROFILE": "<profile>",
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
```
For Amazon OpenSearch Serverless (AOSS):
```json
{
"opensearch-mcp-server": {
"command": "uvx",
"args": ["opensearch-mcp-server-py@latest"],
"env": {
"OPENSEARCH_URL": "<endpoint_url>",
"AWS_REGION": "<region>",
"AWS_PROFILE": "<profile>",
"AWS_OPENSEARCH_SERVERLESS": "true",
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
```
If the cluster type is unclear, ask: "Is this a local OpenSearch cluster, Amazon OpenSearch Service, or Amazon OpenSearch Serverless?"
## Scripts
All operations use shared scripts at the skill root:
```bash
bash scripts/start_opensearch.sh
uv run python scripts/opensearch_ops.py <command> [options]
```
See [cli-reference.md](../../cli-reference.md) for the full command reference.
## Critical Rules (MUST follow)
1. **Preflight-check first** — ALWAYS run `preflight-check` as the very first action before creating any index, loading data, or performing any cluster operation. No exceptions.
2. **Agentic search routing** — Flow agents ARE supported on Serverless NextGen. Conversational agents (with memory/RAG) require a managed domain (Amazon OpenSearch Service). If a user asks for "agentic search on Serverless" without specifying type, clarify this distinction.
3. **Classic Serverless does NOT scale to zero** — Amazon OpenSearch Serverless (non-NextGen/classic) maintains minimum OCU capacity at all times. NEVER claim classic Serverless scales to zero. Note: Serverless NextGen DOES support scale to zero.
## Key Rules
- Ask **one** preference question per message.
- **Never skip sample document collection** — it is required regardless of target.
- Show architecture proposals to the user before execution.
- Follow the phases **in order** — do not jump ahead.
- When a step fails, present the error and wait for guidance.
## Workflow Phases
### Phase 0 — Preflight Check (ALWAYS first)
Before anything else, check cluster availability:
```bash
uv run python scripts/opensearch_ops.py preflight-check
```
- `"available"` → proceed to Phase 1.
- `"auth_required"` → ask for credentials, then proceed.
- `"no_cluster"` → run `bash scripts/start_opensearch.sh`, then proceed.
### Phase 1 — Collect Sample Data
Ask for the data source. Supported inputs:
- Built-in datasets (`load-sample --type builtin_imdb`) — uses a small bundled sample (20 titles) by default, no network call. If the user wants a larger sample, ask first, then rerun with `--allow-download` to fetch up to 100k rows from IMDb's public dataset export.
- Local files: JSON, JSONL, CSV, TSV, Parquet (`load-sample --type local_file --value <path>`)
- PDF, DOCX, PPTX, XLSX — use Docling to process. Read [document_processing_guide.md](../../ingest/document-processing/document_processing_guide.md).
- URLs or pasted JSON
Inspect and validate the data (read a sample, confirm schema).
### Phase 2 — Gather Preferences
First, **fork on data type** (from Phase 1). This is the single place where the
unstructured special-casing is resolved — downstream phases stay config-driven.
#### Unstructured documents (PDF/DOCX/PPTX/XLSX)
Apply the [unstructured preset](unstructured_preset.md) — a fixed bundle of
`agentic (flow)` strategy + `neural_sparse` ingest + `semantic_enrichment` cloud sink.
Do **not** ask the strategy question. Confirm the preset with the user in one sentence,
then continue to Phase 3. Only fall through to the structured strategy path if the user
explicitly requests a different strategy.
Then ask **Target** (below).
#### Structured data (JSON/CSV/TSV)
Ask **one at a time**:
1. **Search strategy.**
- **For unstructured documents** (PDF, DOCX, PPTX, etc.): Default to `agentic` search. Do NOT present all five strategies — proceed with agentic as the default. Mention alternatives are available if the user asks.
- **For structured data** (JSON, CSV, etc.): Present all five:
- `bm25` (keyword)
- `dense_vector` (semantic via embeddings)
- `neural_sparse` (semantic via learned sparse representations)
- `hybrid` (combines keyword + semantic)
- `agentic` (LLM-driven multi-step retrieval, requires OpenSearch 3.2+)
2. **Target** (below).
#### Target (both branches)
Where should the search app run?
- `local` (default) — Docker-based, fast iteration, optional AWS deployment later.
- `aws` — Deploy directly to Amazon OpenSearch Serverless. No Docker needed.
### Phase 3 — Plan
Design a search architecture. Read the relevant knowledge files:
- [dense_vector_models.md](dense_vector_models.md)
- [sparse_vector_models.md](sparse_vector_models.md)
- [opensearch_semantic_search_guide.md](opensearch_semantic_search_guide.md)
- [agentic_search_guide.md](agentic_search_guide.md)
- [document_processing_guide.md](../../ingest/document-processing/document_processing_guide.md) (unstructured: source → chunks)
- [local_ase.md](local_ase.md) (unstructured: chunks → searchable index, local target)
- [unstructured_preset.md](unstructured_preset.md) (the unstructured bundle)
Present the plan and wait for user approval.
### Phase 4 — Execute
Execute the plan against the chosen target. Both targets end with the Search Builder UI connected and running.
#### Target: `local`
1. Start or connect to local cluster (preflight already done in Phase 0).
2. Create index, load data, configure pipelines using `opensearch_ops.py` commands.
- **Unstructured data:** follow the local steps in [unstructured_preset.md](unstructured_preset.md#target-local).
3. Launch the UI:
```bash
uv run python scripts/opensearch_ops.py launch-ui --index <index-name>
```
4. Present: http://127.0.0.1:8765
**For Agentic Search:** Ask for AWS credentials for Bedrock. If the unstructured preset is active, use flow agent directly. Otherwise ask about agent type (Flow vs Conversational). See [cli-reference.md](../../cli-reference.md).
After the UI is running, offer:
> 1. **Evaluate search quality** (Phase 5)
> 2. **Deploy to AWS** (Phase 6)
> 3. **Done for now**
#### Target: `aws`
- **Structured data:** Hand off to [aws-setup](../../cloud/aws-setup/SKILL.md) — it handles provisioning, creating the index, loading data, and launching the UI connected to the AWS endpoint.
- **Unstructured data:** Follow the cloud steps in [unstructured_preset.md](unstructured_preset.md#target-cloud).
After the UI is running, offer:
> 1. **Evaluate search quality** (Phase 5)
> 2. **Done for now**
### Phase 5 — Evaluate (Optional)
Read and follow [evaluation_guide.md](evaluation_guide.md). If HIGH severity findings exist, offer to restart from Phase 3.
### Phase 6 — Deploy to AWS (Optional, target: `local` only)
For users who iterated locally and now want to deploy to AWS.
- **Structured data:** Hand off to [aws-setup](../../cloud/aws-setup/SKILL.md). Pass along the **search strategy** so it does not re-ask.
- **Unstructured data:** Chunks already exist locally. Follow the cloud steps in [unstructured_preset.md](unstructured_preset.md#target-cloud).
© opensearch-project · Apache-2.0 · opensearch-project/opensearch-agent-skills