Hopper

View saved version →

---
name: hopper-integrate
description: 'Points a project''s LLM calls at a Hopper model (DeepSeek V4.1 Flash or Gemma 4 31B) through Hopper''s OpenAI-compatible API: OpenAI SDK (Python or JavaScript), LangChain, Vercel AI SDK, LiteLLM, raw HTTP, LiveKit Agents, Pipecat or Vapi. Gets the project a key, shows the planned change (and, for a voice agent, time to first token on its own prompt), and edits code only after the user says go. Use when the user says "switch this app to DeepSeek on Hopper", "swap the LLM for Gemma 4", "move our OpenAI calls to Hopper", "point base_url at Hopper", "set up Hopper in this project", "add a Hopper API key to this repo" or "go ahead" after a hopper-try comparison. Not for trying or comparing models before deciding (hopper-try), speech or transcription (hopper-speak, hopper-transcribe), or running models locally.'
---

# Use a Hopper model in this project

Hopper serves DeepSeek V4.1 Flash (`deepseek-v4.1-flash`) and Gemma 4 31B (`gemma-4-31b`) behind an OpenAI-compatible API at `https://api.withhopper.com/v1`. Any code that talks to the OpenAI chat-completions API can use them by changing the base URL, the key and the model name.

Run this end to end. The user's only steps are reading the plan, opening one link to keep the key, and saying go before you change their code. Never ask them to sign up, copy keys by hand, or install anything Hopper-specific. Explicit instructions from the user override this workflow. If they haven't decided which model fits yet, or ask whether one is good enough, use the `hopper-try` skill in this plugin first.

Paths below start at `${CLAUDE_SKILL_DIR}`, the folder holding this file (if your host doesn't fill it in, use that folder's absolute path). Run the scripts from the project root: they read and write `.env` in the current directory. They need network access to `withhopper.com` and `api.withhopper.com`; in a sandbox (Codex), request escalated permissions for the first script, with the reason "Set up hopper: get this project a Hopper key (network to withhopper.com and api.withhopper.com; writes .env)", and suggest allowing commands that start with `python3` and the script's path. If the user declines, say Hopper couldn't run and ask how to continue.

## 1. Key

Skip this if `HOPPER_API_KEY` is already set, in the environment or in `.env`.

- **A shell with network** (Codex CLI, Claude Code):

  ```bash
  python3 ${CLAUDE_SKILL_DIR}/scripts/hopper_trial.py
  ```

  Gets a trial key ($2 credit) through [agent registration](https://withhopper.com/auth.md), writes `HOPPER_API_KEY` to `.env` without printing it, and saves the registration privately for step 3. Check that `.env` is in `.gitignore`. Never print, commit, or ship the key to a browser.
- **No network from the shell** (ChatGPT's sandbox can't reach Hopper): call the Hopper connector's `create_api_key` tool (name it after the project, pass the chosen `model`). It returns a one-time link where the user copies the key, the `HOPPER_API_KEY=` line for `.env`, and a snippet. Never paste a full key into the chat. Skip step 3.

## 2. Find the LLM calls and plan

Locate every place the project builds an LLM client or calls a chat model: `OpenAI(`/`AsyncOpenAI(`, `new OpenAI(`, `ChatOpenAI(`, `createOpenAI(`/`@ai-sdk/openai`, `litellm.completion(`, `fetch(".../chat/completions")`, or a framework's LLM service. Note the current model, base URL and how the key is read. Pick the model the user chose (default `gemma-4-31b`; `deepseek-v4.1-flash` if they chose DeepSeek in hopper-try or asked for it).

**Voice agents only** (LiveKit Agents, Pipecat, Vapi, or any realtime conversational loop): measure time to first token on the agent's own system prompt and tools before proposing the change:

```bash
python3 -m pip install openai h2        # inside the project's virtualenv (python3 -m venv .venv if none)
set -a; . ./.env; set +a
python ${CLAUDE_SKILL_DIR}/scripts/hopper_ttft.py --prompt path/to/prompt.txt --tools tools.json --baseline
```

- `--prompt` is their system prompt; `--tools` is their tools in OpenAI format (`[{"type": "function", "function": {...}}]`), if any. With no project prompt, run it bare (a synthetic ~4k-token prompt). `--model` picks the model (default `gemma-4-31b`).
- A 10-turn simulated call on one warm HTTP/2 connection with the prompt warmed into the cache, then the same with `--baseline` (the SDK's defaults, no warm-up). About $0.02. `--cold` shows a never-seen prompt.
- Expect `protocol ['HTTP/2']` and a cache hit of 95% or more. Turns with no text mean the prompt calls tools you didn't pass. The random session ID the script puts at the top of the prompt is for measuring only; a real prompt must never do that.

## 3. Plan, and the link to keep the key

With a trial key from step 1, start the claim first so the link goes out with the plan. Confirm the user's email (`git config user.email` is a good guess) and run this in the background. It prints the link and code, then waits:

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/hopper_claim.py user@example.com
```

Can't leave a command running? Add `--no-wait`; run it again later without the flag to resume waiting on the same code.

For a voice agent, send the report below as a fenced `text` block in exactly this layout (not a table), filled in from the script, with nothing before it and at most two one-line notes after it, only if a note changes the decision. Without a known city, drop "· measured from <city>":

```text
Hopper benchmark · <framework> agent · measured from <city>

                         SDK defaults    Tuned client
  First turn             <b1> ms         <h1> ms
  Later turns, median    <b2> ms         <h2> ms
  Prompt cache                           <hit>%

Keep this key: <link>  ·  code <code>  ·  expires in 10 minutes

Next: switch the LLM in <file> to Hopper (client and warm-up only; STT, TTS and tools unchanged). Go ahead?
```

Both columns are Hopper on their prompt and tools; their current provider isn't measured, so don't present either column as it.

For any other project, send:

```text
Hopper · <model>

  Change   <file>: base URL https://api.withhopper.com/v1, key HOPPER_API_KEY, model <model>
  Keeps    prompts, tools, streaming and the rest of the code as they are

Keep this key: <link>  ·  code <code>  ·  expires in 10 minutes

Next: make this change? Go ahead?
```

- Drop the "Keep this key" line when there's no claim link. The block always ends with "Go ahead?".
- When they enter the code, `hopper_claim.py` writes the account key to `.env` and exits 0. The trial key stops working then: restart any running process. Exit 2 means the code expired; run it again for a new one. If they don't keep it, the trial key works until its $2 runs out.

## 4. Connect (after a go)

Change only the LLM client: base URL, key, model, and the settings below. Keep prompts, tools and call sites as they are.

| Project uses | Do this |
| :--- | :--- |
| LiveKit Agents | `${CLAUDE_SKILL_DIR}/references/livekit.md` |
| Pipecat | `${CLAUDE_SKILL_DIR}/references/pipecat.md` |
| Vapi | `${CLAUDE_SKILL_DIR}/references/vapi.md` |
| OpenAI SDK, Python | `${CLAUDE_SKILL_DIR}/references/openai-sdk.md` (HTTP/2 client, one client per process) |
| OpenAI SDK, JavaScript/TypeScript | `new OpenAI({ apiKey: process.env.HOPPER_API_KEY, baseURL: "https://api.withhopper.com/v1" })`, created once and reused |
| LangChain | `ChatOpenAI(model=..., base_url="https://api.withhopper.com/v1", api_key=os.environ["HOPPER_API_KEY"])` (JS: `configuration: { baseURL }`) |
| Vercel AI SDK | `const hopper = createOpenAI({ baseURL: "https://api.withhopper.com/v1", apiKey: process.env.HOPPER_API_KEY })`, then `hopper.chat("<model>")` |
| LiteLLM | `model="openai/<model>"`, `api_base="https://api.withhopper.com/v1"`, `api_key=os.environ["HOPPER_API_KEY"]` |
| Raw HTTP | `POST https://api.withhopper.com/v1/chat/completions` with `Authorization: Bearer $HOPPER_API_KEY` and an OpenAI chat-completions body |

The reference pages are tested against the live API with `gemma-4-31b`; for DeepSeek, change the model name and add the thinking switch below. In voice agents, start the warm-up in the background as the pages do (`asyncio.create_task`); awaiting it delays every call. Read the key from the environment (`HOPPER_API_KEY`), never hard-code it, and add it to `.env.example` or the deploy config's secret list without a value.

Then run the project's own tests or one real request through the changed code path, and report the result in one or two lines.

## Model settings

| Model | Setting |
| :--- | :--- |
| `deepseek-v4.1-flash` | Thinks before answering unless told not to. For direct answers send `chat_template_kwargs: {"thinking": false}` (Python SDK: `extra_body={"chat_template_kwargs": {"thinking": False}}`; JS: pass it in the request body). |
| `gemma-4-31b` | No `reasoning_effort`: any value, even `low`, turns thinking on and adds seconds. |

## Keeping latency low

| Rule | Why |
| :--- | :--- |
| **One client per process**, reused, on HTTP/2 with a long keepalive (Python: `h2` installed and `http2=True`, as the references do). | A new client per request pays a TLS handshake each time. |
| **Identical prefix.** System prompt and tools byte-identical across requests, tools in the same order; per-request data goes at the end. Append history; never rewrite earlier turns. | Hopper's prompt cache matches from the first token. |
| **Stream** where the app shows or speaks text as it arrives, with `stream_options.include_usage`. | First tokens reach the user sooner, and `cached_tokens` shows up in usage. |

## Fails silently

- **HTTP/1.1** in Python means `h2` is missing. The SDK falls back without an error.
- **A timestamp or request ID at the top** of the prompt drops the cache hit to near zero.
- **Tools named in the prompt but not sent** give empty replies on the turns that try to call them.
- **DeepSeek with thinking on** can spend the whole `max_tokens` budget before any answer text.
- **After a claim**, the trial key returns 401. Update everything that holds it (`.env`, Vapi's Custom LLM key, deploy secrets).
- **openai 3.x uses `httpx2`, not `httpx`.** Build Python clients through `openai.DefaultAsyncHttpxClient`, as the references do.

## Reference

| | |
| :--- | :--- |
| Base URL | `https://api.withhopper.com/v1` |
| Models | `deepseek-v4.1-flash` · `gemma-4-31b` (262,144-token context) |
| Prices and context | the connector's `list_models` tool, or https://withhopper.com/console |
| Limits | 2,000 requests/min per key (429 with `Retry-After`) · zero balance returns 402 `insufficient_quota` |
| Keys | https://withhopper.com/console/keys |
| Agent registration | https://withhopper.com/auth.md |
| Errors | https://docs.withhopper.com/errors |

Referenced files: 8 — file references are metadata, not package contents.

View saved version →

---
name: hopper-speak
description: 'Turn text into speech with Hopper text-to-speech (Qwen 3 TTS): play it aloud, save a WAV file, or preview and pick a voice. Needs no setup: the first use registers a key for the agent itself. Use when the user says "read this aloud", "say this out loud", "generate a voiceover", "voiceover for my launch video", "audio for my launch video", "narrate this script", "narration for my demo video", "make a podcast intro", "record an announcement", "voice for my ad", "make an audio file of…", "text to speech", "TTS" or "which voice should I use". Makes the speech track only, not video, music or sound effects. Not for writing a script (plain text), transcribing audio (hopper-transcribe) or running an LLM (hopper-try).'
---

# Speak with Hopper

**Pick the path first.** In ChatGPT, or wherever the shell can't reach Hopper's API, use the Hopper connector's `speak` tool (and `list_voices` to pick a voice): ChatGPT's sandbox can't resolve Hopper's domains, so the script fails there, while `speak` shows an inline audio player. Where you can run commands with network access (Codex CLI, Claude Code), use this skill's script instead: it plays the audio on this machine (or writes the WAV where the user wants it) and uses this agent's own Hopper key, so its usage can move to the user's account later.

`${CLAUDE_SKILL_DIR}` is the folder holding this file (if your host doesn't fill it in, use that folder's absolute path). The script needs network access to `withhopper.com` and `api.withhopper.com`, and writes the agent's key to `~/.config/hopper/`. In a sandbox (Codex), request escalated permissions for the first command, with the reason "Use Hopper speech: create this agent's own Hopper key and synthesize the audio (network to withhopper.com; writes ~/.config/hopper)", and suggest allowing commands that start with `python3` and this script's path so later calls don't ask again. Exit code 3 (`HOPPER_SANDBOX_BLOCKED`) means the sandbox blocked it: rerun the same command with escalation. If the user declines, say Hopper couldn't run and ask how to continue; don't switch to another tool silently. Explicit instructions from the user override these steps.

## Say it

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/hopper_voice.py speak "Text to say" --play               # play it now
python3 ${CLAUDE_SKILL_DIR}/scripts/hopper_voice.py speak --file notes.md --out notes.wav     # save a file
```

- It prints `{"file", "seconds", "voice"}`. Tell the user the file and length, in one line.
- **Play or save:** "read this aloud" and "say it" mean `--play`; "make an audio file" means `--out <name>.wav`. Without either, it writes `speech.wav` in the current folder.
- **Text:** speak what the user asked for, as they'd hear it: drop Markdown symbols, code blocks and URLs unless they asked for them read out. Long text is split and joined automatically; over 4,000 characters it stops and asks for `--max-chars` so a long read is never a surprise (about $0.005 per 1,000 characters).
- **Voices:** `voices` lists ids with descriptions, tags and gender. Pick by id or name with `--voice`. The default is a neutral conversational American voice. For a preview, say one short sentence in two or three candidate voices.
- Audio is 24 kHz mono WAV. English is the tested language.

## Key

The first run with no `HOPPER_API_KEY` (environment or the project's `.env`) registers a key for the agent itself with a small trial credit (no sign-up, [agent registration](https://withhopper.com/auth.md)) and saves it to `~/.config/hopper/credentials.json`, mode 600. Never print it or copy it into the project. `status` says where the key comes from without showing it.

To move it to the user's account, see the next section.

## When the trial credit runs low

The agent's own key starts with a small trial credit. When it runs low the script prints `HOPPER_HANDOVER low_credit` (exit 0), and when it runs out, `HOPPER_HANDOVER out_of_credit` (exit 4). Either way:

1. Tell the user once, in a line or two, what Hopper has done for this task (the `used=` text) and that the agent's Hopper key is running low, and offer to keep it on their own Hopper account. Don't mention it again in the same task if they decline.
2. If they agree, confirm their email (`git config user.email` is a good guess) and run `claim <email> --no-wait`. Show the link and the 6-digit code; the user enters the code on withhopper.com, never in this chat.
3. Run `claim <email>` to wait. When it prints `Claimed`, carry on: the script uses the account key from then on, with the same history.

## In an application's code

To add Hopper text-to-speech (Qwen 3 TTS) to an application rather than speak now, follow https://docs.withhopper.com/tts: `POST https://api.withhopper.com/v1/audio/speech` with `model: qwen3-tts`, a voice id, `input` up to 1,000 characters, and `stream: true` for the lowest time to first audio.

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: hopper-transcribe
description: 'Transcribe speech in an audio or video file with Hopper speech-to-text (Nemotron ASR), with word timestamps. Takes WAV, MP3, M4A, voice memos and video such as MP4 or MOV (decoded with ffmpeg). Needs no setup: the first use registers a key for the agent itself. Use when the user says "transcribe this", "what does this recording say", "check my video", "what''s said in this video", "review the voiceover in my launch video", "captions for my video", "subtitles", "caption this", "meeting notes from this recording", "summarize this call", "pull quotes from this interview", "speech to text" or "STT". Works from the spoken words only, not the visuals. Not for generating audio (hopper-speak) or running an LLM (hopper-try).'
---

# Transcribe with Hopper

**Pick the path first.** In ChatGPT, or wherever the shell can't reach Hopper's API, use the Hopper connector's `transcribe` tool: pass an attached file as it is (`audio_file`), or a public URL. ChatGPT's sandbox can't resolve Hopper's domains, so the script fails there. Where you can run commands with network access (Codex CLI, Claude Code), use this skill's script instead: it reads files on this machine directly, in any format, and uses this agent's own Hopper key, so its usage can move to the user's account later.

`${CLAUDE_SKILL_DIR}` is the folder holding this file (if your host doesn't fill it in, use that folder's absolute path). The script needs network access to `withhopper.com` and `api.withhopper.com`, and writes the agent's key to `~/.config/hopper/`. In a sandbox (Codex), request escalated permissions for the first command, with the reason "Use Hopper transcription: create this agent's own Hopper key and transcribe the audio (network to withhopper.com; writes ~/.config/hopper)", and suggest allowing commands that start with `python3` and this script's path so later calls don't ask again. Exit code 3 (`HOPPER_SANDBOX_BLOCKED`) means the sandbox blocked it: rerun the same command with escalation. If the user declines, say Hopper couldn't run and ask how to continue; don't switch to another tool silently. Explicit instructions from the user override these steps.

## Transcribe

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/hopper_voice.py transcribe path/to/recording.m4a          # plain text
python3 ${CLAUDE_SKILL_DIR}/scripts/hopper_voice.py transcribe call.wav --json                # text, words with start/end seconds
```

- **Formats:** 16-bit mono WAV goes up as is. Anything else (MP3, M4A, AIFF, FLAC, MP4, MOV) is decoded with `ffmpeg`; if it's missing, tell the user the one install command the script prints.
- **Length:** long recordings are split into uploads under the 25 MB limit and the timestamps are joined back, so any length works; it's about $0.05 per hour of audio.
- **A URL:** download it to a temp file first, then transcribe the file.
- **Output:** answer what the user asked (a summary, action items, a quote) from the transcript, and quote it exactly when they want exact words. Use `--json` for captions, timestamps or who-said-when questions. The model writes lowercase text without punctuation, English only, and can mishear names and brands: say so when a name matters.
- `no speech detected` means the file has no audible speech, not an error.

## Key

The first run with no `HOPPER_API_KEY` (environment or the project's `.env`) registers a key for the agent itself with a small trial credit (no sign-up, [agent registration](https://withhopper.com/auth.md)) and saves it to `~/.config/hopper/credentials.json`, mode 600. Never print it or copy it into the project. `status` says where the key comes from without showing it.

To move it to the user's account, see the next section.

## When the trial credit runs low

The agent's own key starts with a small trial credit. When it runs low the script prints `HOPPER_HANDOVER low_credit` (exit 0), and when it runs out, `HOPPER_HANDOVER out_of_credit` (exit 4). Either way:

1. Tell the user once, in a line or two, what Hopper has done for this task (the `used=` text) and that the agent's Hopper key is running low, and offer to keep it on their own Hopper account. Don't mention it again in the same task if they decline.
2. If they agree, confirm their email (`git config user.email` is a good guess) and run `claim <email> --no-wait`. Show the link and the 6-digit code; the user enters the code on withhopper.com, never in this chat.
3. Run `claim <email>` to wait. When it prints `Claimed`, carry on: the script uses the account key from then on, with the same history.

## In an application's code

To add Hopper speech-to-text (Nemotron ASR) to an application, follow https://docs.withhopper.com/stt: `POST https://api.withhopper.com/v1/audio/transcriptions` (`model: nemotron-asr`, 16-bit PCM or WAV) for files, or the WebSocket stream for live audio.

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: hopper-try
description: 'Tests DeepSeek V4.1 Flash and Gemma 4 31B on the user''s own prompts: finds real prompts in the project or chat, runs both side by side with time to first token, tokens per second and cost, and gives a verdict per example. Changes no code. Use when asked "there''s a new DeepSeek model, how is it? test it for my use case", "DeepSeek V4.1 Flash any good? try it on my prompts", "is Gemma 4 worth trying for this", "give the new DeepSeek a vibe check", "try this prompt on a few open models", "run our real prompts through DeepSeek", "gemma 4 vs deepseek for this, which one?", "could an open model replace GPT-4.1 here", "is DeepSeek a drop-in replacement for OpenAI here", "worth switching to an open model?", "does DeepSeek handle our function calls reliably", "check if Gemma returns valid JSON for our schema" or "try Hopper". Not for testing their code, comparing files, writing prompts, running models locally (Ollama), fine-tuning or published benchmark scores; to switch the project''s model, use hopper-integrate.'
---

# Try open models on your own prompts

Hopper serves DeepSeek V4.1 Flash (`deepseek-v4.1-flash`) and Gemma 4 31B (`gemma-4-31b`) behind an OpenAI-compatible API at `https://api.withhopper.com/v1`. This skill answers "would one of these work for my use case?" with the user's real prompts, not a generic demo. It measures and shows; it changes no code. Explicit instructions from the user override these steps.

## How to run a model

1. **The Hopper connector's `generate` tool**, when it's available (ChatGPT, Claude, any host with the Hopper connector). Prefer it everywhere it exists: it needs no key or network from your shell, and it returns each answer with time to first token, tokens per second, token counts and cost. Pass `models: ["deepseek-v4.1-flash", "gemma-4-31b"]`, the user's `system` prompt and `prompt` (or `messages` for a conversation), and keep `reasoning` off unless the user asks for thinking. In ChatGPT, always use `generate`: its sandbox can't reach Hopper's API, so scripts there fail.
2. **This skill's script**, only when there's no `generate` tool and you can run commands with network access (Codex CLI, Claude Code):

   ```bash
   python3 ${CLAUDE_SKILL_DIR}/scripts/hopper_try.py --system-file prompt.txt "first example" "second example"
   python3 ${CLAUDE_SKILL_DIR}/scripts/hopper_try.py --examples examples.json --tools tools.json --json
   ```

   `${CLAUDE_SKILL_DIR}` is the folder holding this file (if your host doesn't fill it in, use that folder's absolute path). It runs every example on both models, streamed on a warm connection, and prints each answer with TTFT, tokens per second and token counts (it doesn't report cost; say so if the user asks, or point them to the console's usage page). `--examples` takes a JSON list of strings, `{"system", "prompt"}` objects or `{"messages": [...]}`; `--tools` sends OpenAI-format tools and prints each tool call with whether its arguments are valid JSON; `--models` narrows the list. Standard library only. The key comes from `HOPPER_API_KEY` or the project's `.env`; with none, the first run registers a key for the agent itself (small trial credit, no sign-up, [agent registration](https://withhopper.com/auth.md)) in `~/.config/hopper/`, never in the project. In a sandbox (Codex), request escalated permissions for the first run, with the reason "Try Hopper models: run your prompts on DeepSeek V4.1 Flash and Gemma 4 31B (network to withhopper.com and api.withhopper.com; writes ~/.config/hopper)", and suggest allowing commands that start with `python3` and the script's path. Exit 3 (`HOPPER_SANDBOX_BLOCKED`) means the sandbox blocked it: rerun with escalation.
3. Neither available: say Hopper can't run here and give the user `https://withhopper.com/console` to try the models in the browser.

## 1. Find real prompts

- **In a project:** look for what the app actually sends: system prompts (`system`, `SYSTEM_PROMPT`, `prompt.txt`, `prompts/`), `messages=` and `chat.completions.create` calls, prompt templates, eval fixtures and test cases with sample inputs, and tool definitions. Note the model the project calls today (`model=`, `base_url`). Pick 2–5 representative inputs; fill template variables with realistic values from fixtures or tests, not placeholders.
- **In chat:** use what the user pasted. If they gave nothing, ask for 2–5 real examples (a system prompt and a few typical user messages, or a JSON schema they need back) in one short question.
- Read the prompts; don't run the user's application.

## 2. Run

Run every example on both models with the same settings. Use `max_tokens` large enough for a full answer (1024 by default; more for long outputs). For JSON-output checks, put the schema in the prompt the way the app does and judge whether the output parses and matches. For function calls, use the script with `--tools` where you can; with `generate` (which takes no tools), put the tool definitions in the system prompt as the app describes them, ask for the call as JSON, and say this approximates native tool calling.

## 3. Report

For each example, a short block:

```text
Example 1 · <what it tests, in a few words>

DeepSeek V4.1 Flash · TTFT <ms> ms · <n> tok/s · $<cost>
<answer, trimmed to the part that matters>

Gemma 4 31B · TTFT <ms> ms · <n> tok/s · $<cost>
<answer>

Verdict: <one line: which answer fits the task better and why, or both fine>
```

Then one line overall: which model fits this use case, and anything that failed (invalid JSON, a wrong tool, a missed instruction). If the user named their current model, say it wasn't run here unless you ran it; don't invent its numbers. Base verdicts on the answers you saw, not on reputation. Report numbers as measured; don't call either model or Hopper faster, better or cheaper than anything else.

## 4. Offer the next step (don't do it)

End with one question that offers to put the model in their code, and wait for the answer. In a project, offer the switch (and the key it needs); in a chat, offer the key and snippet. You may add "or test more examples first" to the same question, but never offer only more testing:

- **Use it in code:** an API key and the snippet. With the connector, call `create_api_key` (name it after the project; pass the chosen `model`): it returns a one-time link to copy the key and a ready snippet. Never paste a full key into the chat.
- **Switch this project:** the `hopper-integrate` skill in this plugin points the project's OpenAI-compatible client at Hopper after the user says go.
- **Test more:** more examples, a longer conversation, or other settings.

## First run (setup)

When this skill is the user's first contact with Hopper and they gave no prompt, get to a live answer in under a minute:

1. Ask for one short prompt from their work in a single line; if they'd rather not, use a neutral one ("Explain what an API rate limit is in two sentences.").
2. Run it on both models with `generate` (or the script) and show the side-by-side block.
3. Ask what they want to use it for: test it on their task (continue this skill with real examples), add it to their app (`create_api_key` and the snippet, or `hopper-integrate` in a project), or audio (the `hopper-speak` and `hopper-transcribe` skills: Qwen 3 TTS and Nemotron ASR).

Referenced files: 2 — file references are metadata, not package contents.