> ## Documentation Index
> Fetch the complete documentation index at: https://zerogpu-claude-friendly-johnson-fww5io.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Claude Skill

> Upload the ZeroGPU Skill to Claude (Desktop or Web) so Claude follows ZeroGPU best practices when you ask it to classify, extract, redact, or summarize content.

The Claude Skill is a single `SKILL.md` file you upload to Claude (Desktop or Web). Skills are reusable instruction packs that Claude loads on demand: once the ZeroGPU Skill is installed, Claude recognizes when a request is a repeatable, high-volume inference task and follows ZeroGPU's documented patterns instead of improvising. It teaches Claude the right endpoint, the real model catalog, the required authentication, and the rule never to invent results: every answer comes from an actual API call.

ZeroGPU is an ultra-fast, compute-efficient inference provider for apps and agents. We run purpose-built small and nano language models across an edge-powered network for the high-volume, purpose-specific tasks your app or agent runs constantly. Plug in our OpenAI-compatible API and you're live - zero GPU infrastructure, serverless, auto-scaling by default.

## Overview

This guide shows how to add the ZeroGPU Skill to Claude (Desktop or Web) and what changes once it's active. The Skill doesn't replace Claude; it steers Claude toward ZeroGPU for the well-defined tasks small models do best - classification, PII detection and redaction, entity and structured extraction, and summarization. With the Skill installed, Claude routes those tasks to the correct ZeroGPU model through the OpenAI-compatible API, requires your API key before running anything, and returns only output produced by a live API call. By the end you'll know how to install it, the prompts that trigger it, and exactly how Claude behaves when it does.

## Video walkthrough

<iframe width="560" height="315" src="https://www.youtube.com/embed/Xdaxi5PZyVY?si=pWBAGGoE3B4YeEDw" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen />

## Quickstart

### Prerequisites

* The [Claude Desktop](https://claude.ai/download) app, or access to [Claude Web](https://claude.ai).
* A ZeroGPU [API key](https://platform.zerogpu.ai/dashboard).
* A model ID from the [model catalog](/docs/model-catalog) if you want to call a specific model by name.

### Get your ZeroGPU API key

1. Sign in to the [ZeroGPU dashboard](https://platform.zerogpu.ai/dashboard).
2. Open **API Keys** and click **Create key**.
3. Copy the key (starts with `zgpu-api-`).

Keep it handy. Claude will ask for it before it runs any ZeroGPU inference.

### Install the Skill

First, download the Skill from [https://zerogpu.ai/SKILL.md](https://zerogpu.ai/SKILL.md). Then follow whichever path matches how you use Claude.

#### Claude Desktop

<Steps>
  <Step title="Open Claude Desktop">
    Launch the Claude Desktop app.
  </Step>

  <Step title="Go to Settings -> Skills">
    Open **Settings -> Skills**.
  </Step>

  <Step title="Upload the file">
    Add a new Skill and upload the `SKILL.md` file you downloaded.
  </Step>
</Steps>

#### Claude Web (file upload)

<Steps>
  <Step title="Open Claude Web">
    Go to [claude.ai](https://claude.ai) and start (or open) a conversation.
  </Step>

  <Step title="Attach SKILL.md">
    Click the attachment button and upload the `SKILL.md` file you downloaded.
  </Step>

  <Step title="Ask Claude to follow it">
    Tell Claude to follow the attached Skill, then make your request. Claude reads `SKILL.md` from the conversation and applies ZeroGPU's patterns.
  </Step>
</Steps>

### Your first request

With the Skill installed, ask Claude to do a task it recognizes:

```text theme={null}
Redact the PII in this text using ZeroGPU:
"Email John Smith at john@acme.com about invoice 12345."
```

Claude routes the request to ZeroGPU's PII model (`gliner-multi-pii-v1`) through the OpenAI-compatible API. If your API key isn't available yet, Claude asks for it first. Once authenticated, it makes the call and returns the model's actual output:

```text theme={null}
Email [PERSON] at [EMAIL] about invoice 12345.
```

Note that `12345` is not masked: only spans the model recognizes as PII are replaced.

## Usage

The Skill activates whenever a prompt looks like a repeatable inference task. You don't call a command; you describe what you want, and Claude picks the right ZeroGPU model. Two behaviors hold across every example below:

* **Claude requires your API key before executing.** No inference runs until your ZeroGPU API key is available. If it's missing, Claude pauses and asks for it rather than proceeding.
* **Claude never fabricates results.** Every result comes from a live API call to the real model. With the Skill active, Claude will not guess a classification, invent extracted fields, or mock a response before the call runs. If it can't make the call, it tells you why instead of making something up.

Each task below shows a triggering prompt, the ZeroGPU model Claude routes to, and the shape of the response.

### Summarize a long passage

Condense a report, transcript, or thread without spending Claude tokens on the full read.

* **Model:** `llama-3.1-8b-instruct-fast`
* **Triggers on:** "summarize this", "give me the gist", "TL;DR this passage."

```text theme={null}
Summarize this with ZeroGPU:
"The board met Thursday to review Q3 results. Revenue rose 18% year-over-year to
$42M, driven mainly by enterprise renewals and a strong launch in the EU market.
Operating margin slipped to 11% from 14% as headcount grew 30% ahead of the new
data-center buildout. The CFO flagged rising cloud costs as the top risk for Q4
and proposed a hiring freeze on non-engineering roles until margins recover."
```

**Example output (returned after API call)**

```text theme={null}
Q3 revenue grew 18% YoY to $42M on enterprise renewals and EU growth, but operating
margin fell to 11% as headcount rose 30% for the data-center buildout. Citing cloud
costs as the main Q4 risk, the CFO proposed a hiring freeze on non-engineering roles.
```

### Classify against your own labels

Zero-shot classification against a candidate label list you supply in the prompt.

* **Model:** `deberta-v3-small`
* **Triggers on:** "is this positive, negative, or neutral?", "tag this as bug, feature, or question."

```text theme={null}
Classify this with ZeroGPU as positive, negative, or neutral:
"I love how fast this laptop boots up."
```

**Example output (returned after API call)**

```json theme={null}
{ "label": "positive", "scores": { "positive": 0.94, "neutral": 0.04, "negative": 0.02 } }
```

For multi-axis classification (for example sentiment **and** topic at once), Claude routes to `gliner2-base-v1` and returns one chosen label per axis:

```text theme={null}
Classify this support ticket by sentiment and topic with ZeroGPU:
"Support replied quickly but the fix didn't work."
```

```json theme={null}
{ "sentiment": "negative", "topic": "support" }
```

### Classify ad-tech / contextual categories

Standard IAB content and audience taxonomy labels.

* **Model:** `zlm-v1-iab-classify-edge` (use the `-enriched` variant for topics, keywords, and intent)
* **Triggers on:** "what IAB category is this?", "tag this article for ad targeting."

```text theme={null}
What IAB category is this, using ZeroGPU?
"The Lakers signed a new point guard ahead of the playoffs."
```

**Example output (returned after API call)**

```json theme={null}
{
  "categories": [
    { "id": "IAB17-44", "name": "Basketball", "confidence": 0.97 }
  ]
}
```

### Classify a domain by name

Map a bare domain to IAB categories, topics, and intent without fetching the page - the input is just the hostname, which keeps the payload tiny for bidstream and contextual targeting.

* **Model:** `zlm-v1-iab-domain-classifier`
* **Triggers on:** "what categories is this domain?", "classify indeed.com for targeting."

```text theme={null}
Classify this domain with ZeroGPU:
"indeed.com"
```

**Example output (returned after API call)**

```json theme={null}
{
  "domain": "indeed.com",
  "categories": [
    { "id": "IAB4", "name": "Careers", "confidence": 0.96 }
  ]
}
```

### Moderate content for safety

Screen text for unsafe or policy-violating content and get OpenAI-style moderation signals back - useful as a lightweight safety layer in front of your app or another model. See the [moderation benchmark](https://zerogpu.ai/benchmarks/moderation-edge) for accuracy and latency results.

* **Model:** `zlm-v1-moderation-edge`
* **Triggers on:** "moderate this", "is this safe?", "flag any harmful content."

```text theme={null}
Moderate this with ZeroGPU:
"I am so angry at this person that I want to hurt them. They are worthless and
should be scared of what I might do next."
```

**Example output (returned after API call)**

```json theme={null}
{
  "model": "zlm-v1-moderation-edge",
  "results": [
    {
      "flagged": true,
      "unsafe_score": 1,
      "categories": {
        "hate": false,
        "hate/threatening": false,
        "harassment": true,
        "harassment/threatening": true,
        "self-harm": false,
        "self-harm/intent": false,
        "self-harm/instructions": false,
        "sexual": false,
        "sexual/minors": false,
        "violence": true,
        "violence/graphic": false,
        "illicit": true,
        "illicit/violent": true
      },
      "category_scores": {
        "hate": 0.21574,
        "hate/threatening": 0.168273,
        "harassment": 0.82545,
        "harassment/threatening": 0.957703,
        "self-harm": 0.015232,
        "self-harm/intent": 0.017179,
        "self-harm/instructions": 0.01807,
        "sexual": 0.035671,
        "sexual/minors": 0.094207,
        "violence": 0.665897,
        "violence/graphic": 0.198346,
        "illicit": 0.732167,
        "illicit/violent": 0.780693
      }
    }
  ]
}
```

### Detect PII

Find personally identifiable information and return it as structured data, without altering the source text.

* **Model:** `gliner-multi-pii-v1`
* **Triggers on:** "find all PII", "what personal info is in this?", "detect PII."

```text theme={null}
Detect PII in this text with ZeroGPU:
"Contact Jane Doe at jane@example.com or +1 (415) 555-1212."
```

**Example output (returned after API call)**

```json theme={null}
[
  { "category": "identity", "label": "person", "text": "Jane Doe",          "score": 0.96 },
  { "category": "contact",  "label": "email",  "text": "jane@example.com",  "score": 0.99 },
  { "category": "contact",  "label": "phone",  "text": "+1 (415) 555-1212", "score": 0.95 }
]
```

To **mask** PII inline instead of listing it, ask Claude to redact: the same model returns `[LABEL]` placeholders, as shown in the Quickstart.

### Extract named entities

Custom-label named-entity recognition: you name the entity types, the model finds the spans.

* **Model:** `gliner2-base-v1`
* **Triggers on:** "extract all people, organizations, and locations", "find every product mention."

```text theme={null}
Extract the people, organizations, and locations from this with ZeroGPU:
"Apple CEO Tim Cook met with Sundar Pichai in Cupertino on Monday."
```

**Example output (returned after API call)**

```json theme={null}
[
  { "label": "organization", "text": "Apple",         "score": 0.98 },
  { "label": "person",       "text": "Tim Cook",      "score": 0.97 },
  { "label": "person",       "text": "Sundar Pichai", "score": 0.96 },
  { "label": "location",     "text": "Cupertino",     "score": 0.91 }
]
```

### Extract fields into JSON

Pull specific named fields out of free text into a structured object, defined by a schema Claude builds from your request.

* **Model:** `gliner2-base-v1`
* **Triggers on:** "extract the contact info as JSON", "parse this into fields."

```text theme={null}
Extract the name, email, and phone as JSON with ZeroGPU:
"Reach Maria Lopez at maria.lopez@acme.io or 415-555-0188."
```

**Example output (returned after API call)**

```json theme={null}
{
  "contact": {
    "name": "Maria Lopez",
    "email": "maria.lopez@acme.io",
    "phone": "415-555-0188"
  }
}
```

### Translate or reply conversationally

A compact instruct model for short conversational replies, translation, and intent detection - pass an optional system instruction to set its role.

* **Model:** `LFM2.5-1.2B-Instruct`
* **Triggers on:** "translate this", "write a short reply", "draft an in-app message."

```text theme={null}
Reply to this with ZeroGPU, as a friendly fitness-app assistant:
"I just completed a 5K run in 28 minutes. Give me a short motivational follow-up
message."
```

**Example output (returned after API call)**

```text theme={null}
Nice work - a 28-minute 5K is a strong pace! Keep that momentum going and see if
you can shave off a few seconds on your next run. You've got this.
```

### Reason through a decision

A small reasoning model that thinks step by step before committing - useful for triage, routing, and multi-step decisions where you want to see the why, not just the answer.

* **Model:** `LFM2.5-1.2B-Thinking`
* **Triggers on:** "triage this ticket", "reason through this then decide", "route this request."

```text theme={null}
Triage this support ticket with ZeroGPU - assign one team (Billing, Technical,
Account, General) and one priority (Low, Medium, High):
"Our whole team got locked out of the dashboard this morning after the payment
failed. We have a product demo with a customer in 2 hours and cannot log in.
Card on file should be valid."
```

**Example output (returned after API call)**

```text theme={null}
The lockout follows a failed payment, so the root cause is billing rather than a
technical fault. A customer demo in 2 hours makes this time-critical.

Billing | High
```

### Patterns and recipes

**Sanitize before Claude keeps raw input.** Ask Claude to redact PII first when you don't want personal data captured in the conversation transcript or forwarded downstream. The PII spans never need to stay in plain text.

**Cheap router in front of Claude.** Use a zero-shot or structured classification to triage an incoming message (bug / feature / question, urgent / normal) and only escalate the hard cases to Claude's own reasoning. The classifier call costs a fraction of a full Claude turn.

**Structured extraction over free-form parsing.** For semi-structured text (signatures, invoices, contact blocks), prefer JSON extraction over asking Claude to "parse this into JSON." It's deterministic on the schema, faster, and cheaper.

### Task reference

| Task                | Model                          | Example prompt                                                      |
| ------------------- | ------------------------------ | ------------------------------------------------------------------- |
| Summarize           | `llama-3.1-8b-instruct-fast`   | "Summarize this with ZeroGPU: ..."                                  |
| Zero-shot classify  | `deberta-v3-small`             | "Classify this as positive, negative, or neutral with ZeroGPU: ..." |
| Multi-axis classify | `gliner2-base-v1`              | "Classify by sentiment and topic with ZeroGPU: ..."                 |
| IAB classify        | `zlm-v1-iab-classify-edge`     | "What IAB category is this, using ZeroGPU? ..."                     |
| Domain classify     | `zlm-v1-iab-domain-classifier` | "Classify this domain with ZeroGPU: ..."                            |
| Moderate content    | `zlm-v1-moderation-edge`       | "Moderate this with ZeroGPU: ..."                                   |
| Detect PII          | `gliner-multi-pii-v1`          | "Detect PII in this text with ZeroGPU: ..."                         |
| Redact PII          | `gliner-multi-pii-v1`          | "Redact the PII in this with ZeroGPU: ..."                          |
| Extract entities    | `gliner2-base-v1`              | "Extract the people and organizations with ZeroGPU: ..."            |
| Extract JSON        | `gliner2-base-v1`              | "Extract the name, email, and phone as JSON with ZeroGPU: ..."      |
| Translate / reply   | `LFM2.5-1.2B-Instruct`         | "Reply to this with ZeroGPU: ..."                                   |
| Reason / triage     | `LFM2.5-1.2B-Thinking`         | "Triage this ticket with ZeroGPU: ..."                              |

## Troubleshooting

**Claude doesn't route the task to ZeroGPU** - the Skill activates on intent, so a request that reads like general chat may get answered directly. Add "with ZeroGPU" to the prompt, or confirm the Skill is installed and enabled (Claude Desktop: **Settings -> Skills**; Claude Web: re-attach `SKILL.md` and tell Claude to follow it).

**Claude keeps asking for your API key** - no inference runs until the key is available. In Claude Web there's no settings store, so the key lives only in the current conversation; paste it again as its own message when Claude prompts. In Claude Desktop, re-add the Skill if the key didn't persist across sessions.

**"Invalid API key" or the call is rejected** - the key must start with `zgpu-api-`. You've likely pasted a truncated key or a different credential; copy it again from the [dashboard](https://platform.zerogpu.ai/dashboard).

**Network or "couldn't reach the API" errors** - the machine running Claude must be able to reach `api.zerogpu.ai`. Corporate proxies, VPNs, and firewalls are the usual blockers; allowlist the host or switch networks.

**Claude references a model, parameter, or price that doesn't exist** - this shouldn't happen with the Skill active, since it pins Claude to the real [model catalog](/docs/model-catalog). If it does, the Skill probably isn't loaded - re-download `SKILL.md` from [zerogpu.ai/SKILL.md](https://zerogpu.ai/SKILL.md), re-upload it, and confirm Claude says it's following it.

**Claude picks the wrong model for a task** - routing is driven by intent. Phrase the request with the task verb ("summarize", "redact PII", "classify by sentiment and topic", "moderate this") or name the model from the [model catalog](/docs/model-catalog) directly.

**Empty or low-confidence results** - very short inputs (a word or two) score low across the board. Give the model more context, and check that the source-text language matches your labels - most label sets are English-tuned.

**Rate limited, or a 429 / 5xx error** - back off and retry after a short delay. For bulk or offline workloads, move the job to the [Batch API](/docs/batch/index), which has separate quotas tuned for high-volume processing.

## Conclusion

The ZeroGPU Skill turns Claude into a smart router for the repeatable work small models do best - classification, IAB and domain tagging, PII detection and redaction, entity and JSON extraction, summarization, moderation, and lightweight reasoning - so Claude's own reasoning is spent only where it's needed and every result comes from a real API call. Install it once, keep your API key handy, and describe the task in plain language. For anything beyond interactive use, read your key from environment variables or a secrets manager rather than pasting it into a chat - see [Production patterns](/docs/production-patterns).

<CardGroup cols={2}>
  <Card title="Model Catalog" icon="layer-group" href="/docs/model-catalog">
    Browse every model the Skill routes to and pick the best fit.
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/responses">
    Explore the full OpenAI-compatible API surface.
  </Card>

  <Card title="Cookbook" icon="book" href="/cookbook/index">
    Worked examples for classification, extraction, and batch jobs.
  </Card>

  <Card title="Join Discord" icon="discord" href="https://discord.gg/Ad5KZvAyky">
    Ask questions and share what you're building.
  </Card>
</CardGroup>