Documentation Index

Fetch the complete documentation index at: https://docs.zerogpu.ai/llms.txt
Use this file to discover all available pages before exploring further.

🔐 Sanitize a CSV of Customer Feedback with the ZeroGPU Router Plugin

This notebook demonstrates how to use the zerogpu-router plugin so that Claude Code can scrub personal data out of a raw CSV export, all from a single natural-language prompt. You hand Claude a feedback_export.csv whose free-text column is full of customer names, emails, and phone numbers, and you get back two files: a clean copy that is safe to share, and a PII audit log of exactly what was removed and where. By combining Claude Code's plugin system and ZeroGPU's PII-aware nano models, this notebook walks you through a practical pattern where Claude orchestrates the file work while ZeroGPU does the high-volume, well-defined redaction, so raw PII never has to live in your transcript.

For the full reference, see the Claude Code plugin integration guide.

In this notebook, you'll explore:

• Claude Code: Anthropic's agentic coding tool that runs Claude directly in your terminal, with file editing, command execution, and a plugin system that extends sessions with custom slash commands and skills. Here it reads the CSV, loops over every row, and assembles the output files while routing the redaction work to ZeroGPU.
• ZeroGPU: 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.

This setup not only demonstrates a practical application of PII redaction at scale, but also provides a flexible framework that can be adapted to other real-world scenarios requiring consistent, auditable handling of sensitive free-text data.

🎥 Watch the Video Guide

📦 Installation

First, install the ZeroGPU CLI, which is the binary every router skill wraps. You'll also need Claude Code itself (npm install -g @anthropic-ai/claude-code) and Node.js 20 or newer.

```bash theme={null}
npm install -g zerogpu-cli
zerogpu --version

Next, start a Claude Code session by running `claude` in your terminal, then add the marketplace and install the `zerogpu-router` plugin. This is what exposes every ZeroGPU command as a Claude Code skill:



```text theme={null}
/plugin marketplace add zerogpu/zerogpu-router
/plugin install zerogpu-router@zerogpu
/reload-plugins

Confirm it's loaded with /plugin. You should see zerogpu-router - enabled. For the full setup, including CI-friendly flags, see the Claude Code plugin integration guide.

🔑 Setting Up API Keys

You'll need to set up your ZeroGPU credentials so that every skill call works without re-prompting. This ensures Claude Code can reach ZeroGPU's inference API securely.

You can go to here to get an API key and Project ID from ZeroGPU. The key starts with zgpu-api- and the Project ID (UUID) is on the project settings page.

Sign in once from inside your Claude Code session. You'll be prompted for your API key and Project ID, and both are persisted to your config file:

```text theme={null}
/zerogpu-router:signin

Before you run anything, confirm the CLI is installed and you're signed in. `status` exits `0` and prints your masked API key when everything is wired up:



```bash theme={null}
zerogpu --version     # CLI is on your PATH
zerogpu status        # exits 0 and shows your masked API key when signed in

ZeroGPU CLI 1.x.x
Signed in as project 4ed3e5bb...fd1a
API key: zgpu-api-************XXXX

If status reports you're not signed in, run /zerogpu-router:signin again before continuing.

🔐 Redact PII with ZeroGPU

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. In this section, we will redact PII from a single support comment as an example, so you can see exactly what the model gives back before pointing it at a whole file.

The redact-pii skill detects PII spans and replaces each one in-line with an uppercase [LABEL] placeholder. It routes to gliner-multi-pii-v1 with mask: "label".

```text theme={null}
/zerogpu-router:redact-pii "Spoke to Sarah Chen but my refund never came. Call me at +1 415-555-0182 or email dana.morris@gmail.com."

```plaintext
Spoke to [PERSON] but my refund never came. Call me at [PHONE_NUMBER] or email [EMAIL].

Note that only spans the model recognizes as PII are replaced. Names, phone numbers, and emails come back masked; an order number or internal ticket ID would pass through untouched.

🎉 ZeroGPU effortlessly strips the personal data out of free text in one call, providing a cheap, consistent redaction layer for AI integration!

🧾 Sanitize a CSV of Customer Feedback

This section takes a raw CSV export whose free-text column is full of personal data and produces a clean copy plus a PII audit log, with Claude orchestrating the loop and ZeroGPU doing the redaction on every row.

Your support tool exports feedback_export.csv. The comment column is open-ended text where customers typed whatever they wanted, including their names, emails, phone numbers, and sometimes billing addresses. Before this file can go to a dashboard, a Slack channel, or a Git fixture, the PII has to come out. Compliance also wants a record of what was scrubbed, not just a clean file.

Doing this by hand is error-prone, and one missed phone-number format leaks a customer. Regex is brittle. This recipe does it with a PII-aware model, consistently, across every row.

Step 1: Prepare the input CSV

Place your export in the working directory. The recipe assumes a CSV with at least one free-text column to sanitize; all other columns pass through untouched.

```csv theme={null}
id,date,rating,comment
1001,2026-05-21,2,"Spoke to Sarah Chen but my refund never came. Call me at +1 415-555-0182 or email dana.morris@gmail.com."
1002,2026-05-22,5,"Marcus Rivera was super helpful, thanks!"
1003,2026-05-22,1,"Double charged again. Billing email is priya.patel@northwind-labs.com, acct under James Okafor."

Keep a stable, unique `id` column. It's what links a redacted row back to its audit entries. The `date` and `rating` columns are copied verbatim, and `comment` is the only column the models touch. If you don't have an `id` column, ask Claude to add a row index first.

### Step 2: Kick off the workflow with one prompt

In your Claude Code session, in the directory containing the CSV, paste this. That's the whole interaction; everything after it is what Claude does on your behalf.



```text theme={null}
Sanitize feedback_export.csv:
1. Redact PII in the `comment` column and write the result to feedback_clean.csv,
   keeping id, date, and rating unchanged.
2. Produce pii_audit.csv listing every PII entity found, one row per entity, with
   columns: id, category, label, value.
Leave all non-comment columns exactly as they are.

Step 3: Claude reads and parses the CSV

First, Claude opens feedback_export.csv, identifies the header row, and isolates the comment column as the field to process. It holds the other columns aside to re-attach unchanged. No model calls happen yet; this is just file parsing.

Step 4: Per row, redact the comment with redact-pii

For each row, Claude sends the comment value to redact-pii, which returns the masked text that goes into the clean sheet.

```text theme={null}
/zerogpu-router:redact-pii "Spoke to Sarah Chen but my refund never came. Call me at +1 415-555-0182 or email dana.morris@gmail.com."

```plaintext
Spoke to [PERSON] but my refund never came. Call me at [PHONE_NUMBER] or email [EMAIL].

Step 5: Per row, inventory the PII with extract-pii

For the same comment, Claude also calls extract-pii, which returns the PII entities as structured JSON without modifying the text. This is what populates the audit log. Claude tags each returned entity with the row's id so it can be traced back.

```text theme={null}
/zerogpu-router:extract-pii "Spoke to Sarah Chen but my refund never came. Call me at +1 415-555-0182 or email dana.morris@gmail.com." -c identity,contact

```json theme={null}
[
  { "category": "identity", "label": "person", "text": "Sarah Chen", "score": 0.96 },
  { "category": "contact",  "label": "phone",  "text": "+1 415-555-0182", "score": 0.95 },
  { "category": "contact",  "label": "email",  "text": "dana.morris@gmail.com", "score": 0.99 }
]

Why two calls per row? redact-pii gives you the masked text; extract-pii gives you the itemized list of what was masked. They run on the same PII model but serve different outputs: the shareable file versus the compliance trail. extract-pii defaults to -t 0.5 and -c identity,contact; add financial, medical, or credentials if your text contains them, and raise -t to reduce false positives.

Step 6: Claude assembles the two output files

Claude loops Steps 4 and 5 across every row, then writes both files.

feedback_clean.csv keeps the same schema as the input, with comment now masked:

```csv theme={null}
id,date,rating,comment
1001,2026-05-21,2,"Spoke to [PERSON] but my refund never came. Call me at [PHONE_NUMBER] or email [EMAIL]."
1002,2026-05-22,5,"[PERSON] was super helpful, thanks!"
1003,2026-05-22,1,"Double charged again. Billing email is [EMAIL], acct under [PERSON]."

`pii_audit.csv` has one row per detected entity, joined to the source row by `id`:



```csv theme={null}
id,category,label,value
1001,identity,person,Sarah Chen
1001,contact,phone,+1 415-555-0182
1001,contact,email,dana.morris@gmail.com
1002,identity,person,Marcus Rivera
1003,contact,email,priya.patel@northwind-labs.com
1003,identity,person,James Okafor

Step 7: Verify before you share

Run a few quick sanity checks before the clean file leaves your machine:

```bash theme={null}

1. Row counts match (header + same number of data rows)

wc -l feedback_export.csv feedback_clean.csv

2. No obvious leftovers; should print nothing

grep -E '@|+?[0-9][0-9 ()-]{7,}' feedback_clean.csv

3. Eyeball the before/after diff

diff <(cut -d, -f4- feedback_export.csv) <(cut -d, -f4- feedback_clean.csv)

If check 2 surfaces anything, it's almost always a domain-specific identifier the standard PII model doesn't cover (internal hostnames, contract numbers, order IDs, card last-fours), not a missed name or email. For those, add an `extract-entities` pass with your own labels and mask those spans too:



```text theme={null}
/zerogpu-router:extract-entities "Order #88231 for acct A-4471 failed." --labels order_id,account_id -t 0.4

You end up with three files. feedback_export.csv is the original raw PII and is not safe to share. feedback_clean.csv has the same rows with comment masked and is safe to share. pii_audit.csv deliberately contains the original PII values, so treat it as a sensitive artifact: store it like any other secret, and never commit it to a public repo or drop it next to the clean file.

🎉 From a single prompt, Claude parsed the CSV, ran redact-pii and extract-pii on every row, and wrote both a shareable clean copy and an auditable PII log, all while the raw personal data stayed out of its reasoning context.

🌟 Highlights

This notebook has guided you through setting up and running a Claude Code workflow with ZeroGPU for sanitizing a CSV of customer feedback. You can adapt and expand this example for various other scenarios requiring consistent, auditable handling of sensitive free-text data.

Key tools utilized in this notebook include:

• Claude Code: Anthropic's agentic coding tool that runs Claude directly in your terminal, with file editing, command execution, and a plugin system that extends sessions with custom slash commands and skills. Here it reads the CSV, loops over every row, and assembles the output files while routing the redaction work to ZeroGPU.
• ZeroGPU: 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.

This comprehensive setup allows you to adapt and expand the example for various scenarios requiring consistent, auditable handling of sensitive free-text data.