Create an Edge Impulse skill

---
name: edge-impulse
description: Interact with an Edge Impulse project via the Studio and Ingestion APIs. Use when asked to upload data, list or relabel samples, trigger training, check job status, or export a deployment. Also use when the user asks anything about their Edge Impulse project.
---

Help the user interact with their Edge Impulse project using the Studio and Ingestion APIs.

## Preparation

Check for credentials in the environment before asking:

- `EI_API_KEY` — Edge Impulse API key (starts with `ei_`)
- `EI_PROJECT_ID` — numeric project ID

If either is missing, ask the user. They can find the API key in the project Dashboard under the **Keys** tab, and the project ID under **Project Info**.

## API reference

Base URL: https://studio.edgeimpulse.com/v1
Ingestion URL: https://ingestion.edgeimpulse.com
OpenAPI spec: https://studio.edgeimpulse.com/openapi.yml

Authentication header for all Studio API requests:

```text
x-api-key: <EI_API_KEY>
```

### Key endpoints

**Project**

```text
GET /api/{projectId}    project info
GET /api/               list all user projects
```

**Samples**

```text
GET    /api/{projectId}/raw-data                    list samples
GET    /api/{projectId}/raw-data/{sampleId}         get one sample
DELETE /api/{projectId}/raw-data/{sampleId}         delete a sample
POST   /api/{projectId}/raw-data/{sampleId}/rename  relabel a sample
```

Use `?category=training|testing|anomaly`, `?limit`, `?offset`, and `?labels` when listing samples.
Relabel body: `{ "newLabel": "label" }`

**Data upload (Ingestion API)**

```text
POST /api/training/data  upload training sample
POST /api/testing/data   upload testing sample
POST /api/anomaly/data   upload anomaly sample
```

Required headers: `x-api-key`, `x-label`, `x-file-name`.
Accepted bodies: Edge Impulse JSON, audio/WAV, image/JPEG, CSV.

Edge Impulse JSON format:

```json
{
  "protected": { "ver": "v1", "alg": "none", "iat": 1735689600 },
  "signature": "empty",
  "payload": {
    "device_name": "device",
    "device_type": "TYPE",
    "interval_ms": 10,
    "sensors": [{ "name": "accX", "units": "m/s2" }],
    "values": [[0.1], [0.2]]
  }
}
```

**Devices**

```text
GET  /api/{projectId}/devices
POST /api/{projectId}/device/{deviceId}/start-sampling
```

Start-sampling body: `{ "label": "...", "category": "training", "intervalMs": 10, "lengthMs": 5000, "sensor": "Inertial" }`

**Impulse**

```text
GET  /api/{projectId}/impulse    get current pipeline definition
POST /api/{projectId}/impulse    update pipeline
```

**Training**

```text
POST /api/{projectId}/jobs/train/{versionId}       start training job → returns jobId
GET  /api/{projectId}/jobs                         list jobs
GET  /api/{projectId}/jobs/{jobId}/status          job status
GET  /api/{projectId}/jobs/{jobId}/stdout/download job log (plain text, not JSON)
```

Jobs are async. Poll `/jobs/{jobId}/status` until `.job.finished` is true, then check `.job.finishedSuccessful`. On failure, fetch `/jobs/{jobId}/stdout/download` and show the relevant error lines. Users can also monitor progress at `https://studio.edgeimpulse.com/studio/<projectId>/jobs`.

**Deployment**

```text
GET  /api/deployment/targets
POST /api/{projectId}/deploy    start build — body: { "deployType": "zip"|"arduino"|"tflite"|"onnx"|... }
GET  /api/{projectId}/deploy    get artifact download URL
POST /api/{projectId}/jobs/build-ondevice-model
GET  /api/{projectId}/deployment/history
GET  /api/{projectId}/deployment/history/{deploymentVersion}/download
```

**Versions**

```text
GET  /api/{projectId}/versions    list snapshots
POST /api/{projectId}/versions    create snapshot
```

**EON Tuner**

```text
POST /api/{projectId}/tuner/start    start AutoML run
GET  /api/{projectId}/tuner/runs     list runs and results
```

**Testing**

```text
POST /api/{projectId}/jobs/classify    classify a sample
GET  /api/{projectId}/test-results     model test results
```

**Organizations (Enterprise)**

```text
GET  /api/organizations
GET  /api/organizations/{orgId}/data/datasets
POST /api/organizations/{orgId}/data/upload
```

### Response shape

Every response has a `success` field:

```json
{ "success": true, ... }
{ "success": false, "error": "message" }
```

Always check `success` before reading other fields. Raise a clear error if `success` is false.

## Python skeleton

```python
import os, requests

API_KEY = os.environ.get("EI_API_KEY") or input("API key: ")
PROJECT_ID = int(os.environ.get("EI_PROJECT_ID") or input("Project ID: "))
STUDIO = "https://studio.edgeimpulse.com/v1/api"
INGEST = "https://ingestion.edgeimpulse.com/api"

s = requests.Session()
s.headers.update({"x-api-key": API_KEY, "Accept": "application/json"})

def get(path, **params):
    r = s.get(f"{STUDIO}/{PROJECT_ID}{path}", params=params)
    r.raise_for_status()
    d = r.json()
    if not d.get("success"):
        raise RuntimeError(d.get("error", "unknown error"))
    return d

def post(path, body=None, base=STUDIO):
    r = s.post(f"{base}/{PROJECT_ID}{path}" if base == STUDIO else f"{base}{path}", json=body)
    r.raise_for_status()
    d = r.json()
    if not d.get("success"):
        raise RuntimeError(d.get("error", "unknown error"))
    return d
```

## Instructions

1. Understand the task from the user's request.
2. Write Python using the skeleton above, or use curl/shell commands for one-off requests.
3. Run the code and show results clearly.
4. For long-running jobs: poll `GET /api/{projectId}/jobs/{jobId}/status` until `.job.finished` is true. If `.job.finishedSuccessful` is false, fetch `GET /api/{projectId}/jobs/{jobId}/stdout/download` (plain text, not JSON) and show the relevant error lines. Always inform the user they can also monitor progress at `https://studio.edgeimpulse.com/studio/<projectId>/jobs`.
5. For unknown endpoints, fetch https://studio.edgeimpulse.com/openapi.yml and find the right path.