EyePop.ai

https://docs.eyepop.ai/developer-documentation
Admin
EyePop.ai is a self-service AI platform for building computer vision applications that transform...
Tokens:119,901
Snippets:790
Trust Score:7.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install @eyepop.ai/eyepop-render-2d and dependencies

Source: https://docs.eyepop.ai/developer-documentation/sdks/node/visualization

Install the required packages for the Node.js example: @eyepop.ai/eyepop, @eyepop.ai/eyepop-render-2d, and canvas.

```bash
npm install --save @eyepop.ai/eyepop @eyepop.ai/eyepop-render-2d canvas
```

--------------------------------

### Session Setup (Python)

Source: https://docs.eyepop.ai/developer-documentation/platform/sources-and-options/sources

Creates a sync worker endpoint with a person detection component.

```APIDOC
## Session Setup (Python)

### Description
Creates a sync worker endpoint with a person detection component.

### Code
```python
from eyepop import EyePopSdk
from eyepop.worker.worker_types import InferenceComponent, Pop

pop = Pop(components=[InferenceComponent(ability="eyepop.person:latest")])

with EyePopSdk.sync_worker(pop=pop) as endpoint:
    ...  # submit a source here
```
```

--------------------------------

### Install eyepop skill with npx skills add

Source: https://docs.eyepop.ai/developer-documentation/agent-skills

Install the eyepop skill using npx. The default command detects agents and asks where to put the skill. Use -a to target a single agent or all detected agents, -g for a global install, and --list to preview the repository contents without installing.

```bash
npx skills add eyepop-ai/eyepop-skills
```

```bash
npx skills add eyepop-ai/eyepop-skills -a claude-code
```

```bash
npx skills add eyepop-ai/eyepop-skills -a '*'
```

```bash
npx skills add eyepop-ai/eyepop-skills -g
```

```bash
npx skills add eyepop-ai/eyepop-skills --list
```

--------------------------------

### Install CLI and run first inference

Source: https://docs.eyepop.ai/developer-documentation

Install the EyePop CLI, authenticate, and run your first inference from the terminal. Requires an active plan and API key from the dashboard.

```bash
# Install — macOS and Linux
brew tap eyepop-ai/eyepop
brew trust eyepop-ai/eyepop
brew install eyepop

# Or, without Homebrew, on Linux and macOS:
curl -fsSL https://raw.githubusercontent.com/eyepop-ai/homebrew-eyepop/main/install.sh | sh

# Sign in — opens the browser to log in to your account
eyepop auth login

# Run your first inference with the default person model, on a public-domain sample photo
eyepop run --model eyepop.person:latest --media-path https://raw.githubusercontent.com/eyepop-ai/eyepop-skills/main/skills/eyepop/assets/macgyver.jpg
```

--------------------------------

### eyepop instance start

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Starts the instance container and waits until it reports healthy. Also recreates a container removed by hand. Default wait is 300 seconds. Supports --json, --config-dir, --format, and --wait options.

```text
Start the instance container and wait until it reports healthy.

Also recreates a container that was removed by hand — the generated compose project is the record, so bringing it up is always the same operation.

Usage: eyepop instance start [OPTIONS]

Options:
      --json
          Output as JSON instead of styled tables. Alias for `--format json`

      --wait <WAIT>
          Seconds to wait for the container to report healthy
          
          [default: 300]

      --config-dir <DIR>
          Instance root; everything the instance needs lives under it

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

  -h, --help
          Print help (see a summary with '-h')
```

--------------------------------

### docker compose up - Start the EyePop service

Source: https://docs.eyepop.ai/developer-documentation/deploying/vms/milestone/configuration

Starts the EyePop Milestone IVA container using the compose file and .env.

```bash
docker compose -f compose.release.yaml up -d

```

--------------------------------

### Install EyePop Node SDK

Source: https://docs.eyepop.ai/developer-documentation/sdks/node

Install the @eyepop.ai/eyepop package for Node.js using npm.

```bash
npm install --save @eyepop.ai/eyepop
```

--------------------------------

### Get help for a specific command: eyepop get datasets --help

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Run this command to see the flags and options for any EyePop CLI command. The page is generated from such help output, so this is the canonical way to get up-to-date command details.

```bash
eyepop get datasets --help
```

--------------------------------

### eyepop run examples

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Examples of running a model, pop, or session against media. The first two run a model on one or more images, the third runs a pop on a video, and the fourth runs a session on a URL. Each command uses flags for target and media path.

```bash
eyepop run --model eyepop.person:latest --media-path image.jpg
```

```bash
eyepop run --model eyepop.person:latest --media-path image1.jpg --media-path image2.jpg
```

```bash
eyepop run --pop people-common-objects --media-path video.mp4
```

```bash
eyepop run --session <session-uuid> --media-path https://example.com/frame.jpg
```

--------------------------------

### Install EyePop Python SDK with relay extra

Source: https://docs.eyepop.ai/developer-documentation/deploying/cloud/private-cameras

Install the `eyepop` package with the `relay` extra, which pins the media library used to read the camera. Requires `eyepop` 3.21.1 or newer.

```bash
pip install 'eyepop[relay]'
```

--------------------------------

### Session Setup (Node)

Source: https://docs.eyepop.ai/developer-documentation/platform/sources-and-options/sources

Creates a worker endpoint with a person detection component.

```APIDOC
## Session Setup (Node)

### Description
Creates a worker endpoint with a person detection component.

### Code
```javascript
import { EyePop, PopComponentType } from '@eyepop.ai/eyepop'

const endpoint = await EyePop.workerEndpoint({
    pop: {
        components: [{ type: PopComponentType.INFERENCE, ability: 'eyepop.person:latest' }],
    },
}).connect()

try {
    // submit a source here
} finally {
    await endpoint.disconnect()
}
```
```

--------------------------------

### Building a Pop

Source: https://docs.eyepop.ai/developer-documentation/sdks/python/composable-pops

Example of constructing a Pop pipeline with inference and tracking components, and running it on an image.

```APIDOC
## Build a Pop

### Description
Constructs a Pop pipeline that detects vehicles, tracks them, and reads license plates.

### Code Example
```python
from eyepop import EyePopSdk
from eyepop.worker.worker_types import (
    Pop, InferenceComponent, TrackingComponent, CropForward, MotionModel,
)

pop = Pop(components=[
    InferenceComponent(
        ability="eyepop.vehicle:latest",
        categoryName="vehicles",
        confidenceThreshold=0.8,
        forward=CropForward(
            includeClasses=["car", "truck"],
            targets=[
                TrackingComponent(
                    maxAgeSeconds=5.0,
                    motionModel=MotionModel.CONSTANT_VELOCITY,
                ),
                InferenceComponent(
                    ability="eyepop.vehicle.license-plate:latest",
                    topK=1,
                    forward=CropForward(targets=[
                        InferenceComponent(
                            ability="eyepop.text.recognize.landscape:latest",
                            categoryName="license-plate",
                        ),
                    ]),
                ),
            ],
        ),
    ),
])

with EyePopSdk.sync_worker(pop=pop) as endpoint:
    result = endpoint.upload("street.jpg").predict()
```
```

--------------------------------

### Start the AI Bridge with Docker Compose

Source: https://docs.eyepop.ai/developer-documentation/deploying/vms/milestone/prerequisites

Starts the AI Bridge containers using the production compose file. The AI Bridge registers itself with XProtect and appears under Processing Servers in Management Client.

```bash
docker compose -f docker-compose-production.yml up -d
```

--------------------------------

### eyepop evaluate example invocations

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Example commands for `eyepop evaluate` showing different option combinations: basic ability evaluation, specifying a dataset, adding a partition filter, and using --no-wait for asynchronous operation.

```text
eyepop evaluate --ability my-namespace.find-kittens:latest
```

```text
eyepop evaluate --ability my-namespace.find-kittens:latest --dataset people
```

```text
eyepop evaluate --ability my-namespace.find-kittens:latest --dataset people --partition test
```

```text
eyepop evaluate --ability my-namespace.find-kittens:latest --no-wait
```

--------------------------------

### eyepop get - List or get resources

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Shows the help output for the `eyepop get` command, listing its subcommands (datasets, assets, abilities, groups, pops, models, accounts, keys, deployments, sessions, instances, evals, usage) and common options like --api-key, --json, --format, --log-level, --log-file, and -h/--help.

```text
Get or list resources

Usage: eyepop get [OPTIONS] <COMMAND>

Commands:
  datasets     List or show datasets
  assets       List assets in a dataset
  abilities    List or show abilities
  groups       List ability groups [aliases: group]
  pops         List or show pops
  models       List models by namespaced alias and tag
  accounts     List or show accounts
  keys         List API keys, show one by prefix, or check the key you are using
  deployments  List or show deployments [aliases: deploy, deploys]
  sessions     List or show sessions
  instances    List the account's on-premise instances
  evals        List past evaluations, or show one in flight [aliases: eval]
  usage        Show compute usage and credit status
  help         Print this message or the help of the given subcommand(s)

Options:
      --api-key <KEY>
          API key to authenticate as, overriding EYEPOP_API_KEY and the session.
          
          Prefer EYEPOP_API_KEY when unattended: a flag value is visible in shell history and in process listings.

      --json
          Output as JSON instead of styled tables. Alias for `--format json`

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

      --log-level <LEVEL>
          Log verbosity on stderr: error, warn, info, debug, trace, or per-module targets like `eyepop::api=debug`. Defaults to EYEPOP_LOG_LEVEL, else info

      --log-file [<PATH>]
          Also write the log to a file. Without a path, uses the default filename here, or EYEPOP_LOG_FILE

  -h, --help
          Print help (see a summary with '-h')
```

--------------------------------

### eyepop get datasets - List or show datasets

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Shows the help output for the `eyepop get datasets` subcommand, including the optional NAME argument and options such as --q, --version, --account, --modifiable, --limit, --offset, --filter, and common global options.

```text
List or show datasets

Usage: eyepop get datasets [OPTIONS] [NAME]

Arguments:
  [NAME]
          Dataset name or UUID for detail view

Options:
      --api-key <KEY>
          API key to authenticate as, overriding EYEPOP_API_KEY and the session.
          
          Prefer EYEPOP_API_KEY when unattended: a flag value is visible in shell history and in process listings.

      --json
          Output as JSON instead of styled tables. Alias for `--format json`

  -q, --q <Q>
          Case-insensitive name search (substring; glob matches whole name: *my-*)

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

      --log-level <LEVEL>
          Log verbosity on stderr: error, warn, info, debug, trace, or per-module targets like `eyepop::api=debug`. Defaults to EYEPOP_LOG_LEVEL, else info

      --version <VERSION>
          Specific dataset version

  -a, --account <ACCOUNT>
          Account UUID

      --log-file [<PATH>]
          Also write the log to a file. Without a path, uses the default filename here, or EYEPOP_LOG_FILE

      --modifiable
          Only show modifiable datasets

  -l, --limit <LIMIT>
          Page size (1-1000); defaults to 25 fancy / 100 json

      --offset <OFFSET>
          Page offset (default 0)
          
          [default: 0]

      --filter <FILTER>
          Filter datasets (key=value with glob: name=my-*,searchable=true,assets=12)

  -h, --help
          Print help (see a summary with '-h')
```

--------------------------------

### eyepop instance init help output

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Shows the help text for the `eyepop instance init` command, detailing its options for configuring a new instance. Use `--yes` to accept defaults, `--config` for scripted configuration, and `--dump` to render artifacts without registering.

```text
Set up an EyePop instance on this machine: check prerequisites, register it with your account, generate the compose project and instance configuration, and bring the container up.

Re-running repairs. An existing instance keeps its identity — a wiped volume, a deleted container or a half-written root are all healed by the same command. A genuinely different instance means `eyepop instance delete` first.

On a terminal with nothing supplied it prompts. Use `--yes` to accept defaults, or `--config` plus overriding flags for scripted configuration.

`eyepop init` is an alias for this command.

Usage: eyepop instance init [OPTIONS]

Options:
      --account <ACCOUNT>
          Account to register this instance in; otherwise inferred from the API key or signed-in account

      --json
          Output as JSON instead of styled tables. Alias for `--format json`

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

      --pop <POP>
          Pop the instance serves: a pop name, an ability like eyepop.person:latest, or JSON/YAML (inline or file)

      --name <NAME>
          Instance name; defaults to this machine's hostname

  -c, --config <CONFIG>
          Config file, inline JSON, or YAML; flags override it

      --bind <BIND>
          Host interface to publish on

      --log-level <LOG_LEVEL>
          Runtime log level

      --tag <TAG>
          Runtime image tag; defaults to the tag the platform recommends, or `latest` when it cannot answer

      --profile <PROFILE>
          Hardware family selecting the runtime image. Detected when omitted, and never checked against this machine, so you can render for other hardware

          Possible values:
          - cpu
          - cuda
          - cuda-jetpack6: `cuda-jetpack` was the spelling before it was unified with the image tag (`-jetpack6`); kept as an alias so an existing `--profile` value and any config written by an older CLI still resolve
          - openvino
          - qnn

      --adopt <ADOPT>
          Claim a specific existing instance record by UUID

      --wait <WAIT>
          Seconds to wait for the container to report healthy
          
          [default: 300]

  -y, --yes
          Accept defaults without prompting; the pop defaults to eyepop.person:latest

      --dump
          Render the artifacts and stop — nothing registered, seeded or started
          
          Writes to ./eyepop-instance/, or to that name under --config-dir, and leaves the real instance root untouched. Asks the platform nothing: the pop is written through as given, so only an ability reference renders a body that would boot.

      --config-dir <DIR>
          Instance root; everything the instance needs lives under it

      --api-key <KEY>
          API key to authenticate as, overriding EYEPOP_API_KEY and the session.
          
          Prefer EYEPOP_API_KEY when unattended: a flag value is visible in shell history and in process listings.

      --log-file [<PATH>]
          Also write the log to a file. Without a path, uses the default filename here, or EYEPOP_LOG_FILE

  -h, --help
          Print help (see a summary with '-h')

```

--------------------------------

### Initialize an EyePop instance with eyepop instance init

Source: https://docs.eyepop.ai/developer-documentation/cli/on-premise

Run this command to set up an on-premise instance. It detects the hardware profile, checks prerequisites, installs a registry credential if needed, registers the instance, pulls the runtime image, and brings up the container. The pop defaults to eyepop.person:latest when --yes is used.

```bash
eyepop instance init --pop eyepop.person:latest
```

--------------------------------

### Python: Upload with VideoMode.STREAM

Source: https://docs.eyepop.ai/developer-documentation/platform/sources-and-options/options/video-mode

Example of uploading a video in stream mode using the EyePop Python SDK, allowing predictions to start before the upload completes.

```APIDOC
## Python: Upload with VideoMode.STREAM

### Description
Uploads a video file in stream mode, processing it as it uploads so predictions arrive almost immediately.

### Method
upload

### Endpoint
endpoint.upload("clip.mp4", video_mode=VideoMode.STREAM)

### Parameters
- **path** (string) - Required - Path to the video file to upload.
- **video_mode** (VideoMode) - Required - Set to VideoMode.STREAM to process while uploading.

### Request Example
```python
from eyepop.worker.worker_types import VideoMode

job = endpoint.upload("clip.mp4", video_mode=VideoMode.STREAM)
while result := job.predict():
    print(result)
```

### Response
#### Success Response
- **job** (Job) - A job object that can be used to retrieve predictions.

#### Response Example
```python
# job object returned, predictions can be iterated with job.predict()
```
```

--------------------------------

### Node: Process with VideoMode.STREAM

Source: https://docs.eyepop.ai/developer-documentation/platform/sources-and-options/options/video-mode

Example of processing an uploaded video in stream mode using the EyePop Node SDK, enabling predictions to start before the upload completes.

```APIDOC
## Node: Process with VideoMode.STREAM

### Description
Processes an uploaded video in stream mode, allowing predictions to start as the video uploads.

### Method
process

### Endpoint
endpoint.process({ source: { path: 'clip.mp4', videoMode: VideoMode.STREAM } })

### Parameters
- **source.path** (string) - Required - Path to the video file to upload.
- **source.videoMode** (VideoMode) - Required - Set to VideoMode.STREAM to process while uploading.

### Request Example
```javascript
import { VideoMode } from '@eyepop.ai/eyepop'

const results = await endpoint.process({
    source: { path: 'clip.mp4', videoMode: VideoMode.STREAM },
})
```

### Response
#### Success Response
- **results** (AsyncIterable) - An async iterable of prediction results.

#### Response Example
```javascript
// results is an async iterable of prediction objects
```
```

--------------------------------

### Build a dataset

Source: https://docs.eyepop.ai/developer-documentation/cli/evaluation

Creates a dataset, uploads assets with a partition, and lists assets. Annotate assets before evaluating.

```bash
eyepop create dataset --name people
eyepop create asset --dataset people --media-path ./images --recursive --partition test
eyepop get assets --dataset people
```

--------------------------------

### Verify EyePop CLI installation

Source: https://docs.eyepop.ai/developer-documentation/cli

Checks the installed EyePop CLI version to confirm the installation succeeded.

```bash
eyepop --version
```

--------------------------------

### Add install directory to PATH

Source: https://docs.eyepop.ai/developer-documentation/cli

Adds the EyePop install directory to the PATH environment variable, as suggested when the install script warns the directory is not on PATH.

```bash
export PATH="$HOME/.local/bin:$PATH"
```

--------------------------------

### eyepop top-level help

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Shows the main CLI usage, all commands (auth, instance, get, create, delete, patch, run, evaluate, system, tui, update, help), and global options like --json, --format, -h, -V. The --format option accepts fancy (default), text, or json.

```bash
CLI for interacting with the EyePop ecosystem

Usage: eyepop [OPTIONS] <COMMAND>

Commands:
  auth      Authentication commands
  instance  Manage the EyePop instance on this machine
  get       Get or list resources [aliases: show, ls, list]
  create    Create a resource [aliases: new]
  delete    Delete a resource
  patch     Patch (update in place) a resource
  run       Run inference on media
  evaluate  Evaluate an ability against a dataset [aliases: eval]
  system    Show what this machine is and whether it has what EyePop needs
  tui       Launch the interactive run wizard (choose a model, pick media, run)
  update    Update the CLI to the latest version [aliases: upgrade]
  help      Print this message or the help of the given subcommand(s)

Options:
      --json
          Output as JSON instead of styled tables. Alias for `--format json`

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

  -h, --help
          Print help (see a summary with '-h')

  -V, --version
          Print version
```

--------------------------------

### Install EyePop CLI on Linux via install script

Source: https://docs.eyepop.ai/developer-documentation/cli

Installs the EyePop CLI on Linux (ARM64 and AMD64) using a curl script. The script downloads the release binary, verifies its SHA-256, and installs to `~/.local/bin`. Set `EYEPOP_INSTALL_DIR` or `EYEPOP_VERSION` to customize.

```bash
curl -fsSL https://raw.githubusercontent.com/eyepop-ai/homebrew-eyepop/main/install.sh | sh
```

--------------------------------

### eyepop create dataset - CLI help output

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Shows the usage and options for the `eyepop create dataset` command. Requires --name. Notable defaults: concurrency is 4, format is fancy. The --api-key flag is visible in shell history, so prefer EYEPOP_API_KEY for unattended use.

```text
Create a new dataset

Usage: eyepop create dataset [OPTIONS] --name <NAME>

Options:
      --api-key <KEY>
          API key to authenticate as, overriding EYEPOP_API_KEY and the session.
          
          Prefer EYEPOP_API_KEY when unattended: a flag value is visible in shell history and in process listings.

      --json
          Output as JSON instead of styled tables. Alias for `--format json`

  -n, --name <NAME>
          Dataset name

  -d, --description <DESCRIPTION>
          Description

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

      --log-level <LEVEL>
          Log verbosity on stderr: error, warn, info, debug, trace, or per-module targets like `eyepop::api=debug`. Defaults to EYEPOP_LOG_LEVEL, else info

      --log-file [<PATH>]
          Also write the log to a file. Without a path, uses the default filename here, or EYEPOP_LOG_FILE

  -t, --tags <TAGS>
          Tags (repeatable)

      --searchable
          Make searchable

  -a, --account <ACCOUNT>
          Account UUID

      --media-path <MEDIA_PATH>
          Upload sources on creation (repeatable)

  -r, --recursive
          Recurse into directories (with --media-path)

      --partition <PARTITION>
          Partition label for uploaded media

      --concurrency <CONCURRENCY>
          Upload concurrency
          
          [default: 4]

  -h, --help
          Print help (see a summary with '-h')
```

--------------------------------

### Install EyePop agent skill

Source: https://docs.eyepop.ai/developer-documentation

Install the EyePop skill for an agent harness, then give your agent the provided prompt to install the CLI and walk through the first inference.

```bash
npx skills add eyepop-ai/eyepop-skills
```

--------------------------------

### Create a deployment

Source: https://docs.eyepop.ai/developer-documentation/cli/persistent-sessions

Create a new deployment using either a model alias or a Pop configuration file.

```bash
eyepop create deployment --model eyepop.person:latest
eyepop create deployment --pop ./pop.json
```

--------------------------------

### eyepop create deployment help output

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Shows the full help output for the `eyepop create deployment` command, including usage, options, and their descriptions. Use this to understand how to create a deployment and wait until healthy, printing the session UUID.

```text
Create a deployment, wait until healthy, and print the session UUID

Usage: eyepop create deployment [OPTIONS]

Options:
      --account <ACCOUNT>
          Account UUID

      --api-key <KEY>
          API key to authenticate as, overriding EYEPOP_API_KEY and the session.
          
          Prefer EYEPOP_API_KEY when unattended: a flag value is visible in shell history and in process listings.

      --json
          Output as JSON instead of styled tables. Alias for `--format json`

      --display-name <NAME>
          Display name for the deployment

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

      --log-level <LEVEL>
          Log verbosity on stderr: error, warn, info, debug, trace, or per-module targets like `eyepop::api=debug`. Defaults to EYEPOP_LOG_LEVEL, else info

      --log-file [<PATH>]
          Also write the log to a file. Without a path, uses the default filename here, or EYEPOP_LOG_FILE

      --model <ALIAS_OR_UUID>
          Model to run: alias from `eyepop get models` or model UUID

      --pop <POP>
          Pop to run: alias from `eyepop get pops`, saved pop UUID, ability, or JSON/YAML (inline or file)

      --dashboard
          Enable the dashboard and open it in your default browser once healthy

  -h, --help
          Print help (see a summary with '-h')
```

--------------------------------

### Install EyePop React Native SDK

Source: https://docs.eyepop.ai/developer-documentation/sdks/node

Install the React Native EyePop package along with required dependencies.

```bash
npm install --save @eyepop.ai/react-native-eyepop \
    react-native-canvas react-native-file-access@3.1.1 \
    react-native-tcp-socket react-native-webrtc
```

--------------------------------

### Run with Pop file or inline JSON

Source: https://docs.eyepop.ai/developer-documentation/cli/resources

Shows how to pass a Pop as a JSON or YAML file or inline, and an ability as a one-component Pop.

```bash
eyepop run --pop ./pop.json --media-path image.jpg
eyepop run --pop '{"components":[{"type":"inference","id":1,"ability":"eyepop.person:latest"}]}' --media-path image.jpg
```

--------------------------------

### Install EyePop Python SDK

Source: https://docs.eyepop.ai/developer-documentation/sdks/python

Install the EyePop Python SDK using pip. Requires Python 3.12 or newer.

```bash
pip install eyepop
```

--------------------------------

### Connect to an on-premise instance from the Python SDK

Source: https://docs.eyepop.ai/developer-documentation/cli/on-premise

Uses local mode to point the SDK at `http://127.0.0.1:8080` instead of the cloud. Pass the instance's pop when connecting; the example uploads an image and predicts with the `eyepop.person:latest` inference component. `EYEPOP_LOCAL_MODE=true` in the environment sets `isLocalMode` for you.

```python
from eyepop import EyePopSdk
from eyepop.worker.worker_types import Pop, InferenceComponent

pop = Pop(components=[InferenceComponent(ability="eyepop.person:latest")])

async with EyePopSdk.async_worker(is_local_mode=True, pop=pop) as endpoint:
    job = await endpoint.upload("image.jpg")
    result = await job.predict()
```

--------------------------------

### Search abilities by name

Source: https://docs.eyepop.ai/developer-documentation/cli/resources

Shows how to search abilities by name with the `-q` flag, which is also accepted by `get datasets` and `get pops`.

```bash
eyepop get abilities -q detector
```

--------------------------------

### eyepop create asset - CLI help output

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Shows the usage and options for the `eyepop create asset` command. Requires --media-path and --dataset. Notable defaults: concurrency is 4, format is fancy. The --api-key flag is visible in shell history, so prefer EYEPOP_API_KEY for unattended use.

```text
Upload one or more assets to a dataset

Usage: eyepop create asset [OPTIONS] --media-path <MEDIA_PATH> --dataset <DATASET>

Options:
      --api-key <KEY>
          API key to authenticate as, overriding EYEPOP_API_KEY and the session.
          
          Prefer EYEPOP_API_KEY when unattended: a flag value is visible in shell history and in process listings.

      --json
          Output as JSON instead of styled tables. Alias for `--format json`

      --media-path <MEDIA_PATH>
          Source files, directories, or URLs (repeatable)

  -d, --dataset <DATASET>
          Target dataset name or UUID

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

      --log-level <LEVEL>
          Log verbosity on stderr: error, warn, info, debug, trace, or per-module targets like `eyepop::api=debug`. Defaults to EYEPOP_LOG_LEVEL, else info

      --log-file [<PATH>]
          Also write the log to a file. Without a path, uses the default filename here, or EYEPOP_LOG_FILE

  -r, --recursive
          Recurse into subdirectories

      --partition <PARTITION>
          Partition label (e.g., train, test, val)

      --concurrency <CONCURRENCY>
          Maximum concurrent uploads (1-32)
          
          [default: 4]

      --version <VERSION>
          Target dataset version

  -a, --account <ACCOUNT>
          Account UUID

  -h, --help
          Print help (see a summary with '-h')
```

--------------------------------

### Create resource commands

Source: https://docs.eyepop.ai/developer-documentation/cli/resources

Shows create commands for datasets, assets, abilities, keys, and deployments.

```bash
eyepop create dataset --name people
eyepop create asset --dataset people --media-path ./images --recursive
eyepop create ability --name people-counter --prompt "Count the people" --publish
eyepop create key --name ci
eyepop create deployment --model eyepop.person:latest
```

--------------------------------

### Get machine-readable output with --json

Source: https://docs.eyepop.ai/developer-documentation/cli/getting-started

Adds --json to commands to get raw JSON instead of styled tables. Some commands ignore it or refuse it.

```bash
eyepop get datasets --json
eyepop run --model eyepop.person:latest --media-path image.jpg --json
```

--------------------------------

### Example inference JSON output

Source: https://docs.eyepop.ai/developer-documentation

Example structured JSON output from an inference, containing source dimensions and detected objects with class label, confidence, and bounding box coordinates.

```json
{
  "source_width": 1920,
  "source_height": 1080,
  "objects": [
    { "classLabel": "person", "confidence": 0.95, "x": 100, "y": 50, "width": 80, "height": 200 }
  ]
}
```

--------------------------------

### Connect to an on-premise instance from the Node SDK

Source: https://docs.eyepop.ai/developer-documentation/cli/on-premise

Uses local mode to point the SDK at `http://127.0.0.1:8080` instead of the cloud. Pass the instance's pop when connecting; the example processes an image with the `eyepop.person:latest` inference component. `EYEPOP_LOCAL_MODE=true` in the environment sets `isLocalMode` for you.

```typescript
import { EyePop, Pop, PopComponentType } from '@eyepop.ai/eyepop'

const pop: Pop = {
    components: [{ type: PopComponentType.INFERENCE, ability: 'eyepop.person:latest' }],
}

const endpoint = await EyePop.workerEndpoint({ isLocalMode: true, pop }).connect()
try {
    const results = await endpoint.process({ source: { path: 'image.jpg' } })
    for await (const result of results) {
        console.log(result)
    }
} finally {
    await endpoint.disconnect()
}
```

--------------------------------

### Open a session with a Pop (Node)

Source: https://docs.eyepop.ai/developer-documentation/platform/sources-and-options/sources

Sets up a worker endpoint with a Pop configured for person inference. This session is used by every example on the page; the source submission is replaced in each subsequent example.

```typescript
import { EyePop, PopComponentType } from '@eyepop.ai/eyepop'

const endpoint = await EyePop.workerEndpoint({
    pop: {
        components: [{ type: PopComponentType.INFERENCE, ability: 'eyepop.person:latest' }],
    },
}).connect()

try {
    // submit a source here
} finally {
    await endpoint.disconnect()
}
```

--------------------------------

### eyepop instance help output

Source: https://docs.eyepop.ai/developer-documentation/cli/reference

Shows the help text for the `eyepop instance` command, listing subcommands and options. Use `--json` or `--format` to control output style.

```text
Manage the EyePop instance on this machine.

An instance is EyePop running on hardware you control. These commands operate on the one instance this machine holds; to list every instance in your account, use `eyepop get instances`.

Usage: eyepop instance [OPTIONS] <COMMAND>

Commands:
  init     Set up an EyePop instance on this machine and bring it up
  start    Start the instance container and wait until it is healthy
  stop     Stop the instance container; `instance start` brings it back
  restart  Restart the instance container and wait until it is healthy
  set      Change a setting and recreate the instance container
  logs     Show the instance container's logs
  delete   Delete this machine's instance and everything it installed
  help     Print this message or the help of the given subcommand(s)

Options:
      --json
          Output as JSON instead of styled tables. Alias for `--format json`

      --format <FORMAT>
          How results render on stdout: fancy (human-readable), text (one record per line), or json

          Possible values:
          - fancy: Human-readable output, styled where it helps (default)
          - text:  Plain text output for scripting
          - json:  JSON output

  -h, --help
          Print help (see a summary with '-h')

```

--------------------------------

### Open a session with a Pop (Python)

Source: https://docs.eyepop.ai/developer-documentation/platform/sources-and-options/sources

Sets up a synchronous worker endpoint with a Pop configured for person inference. This session is used by every example on the page; the source submission is replaced in each subsequent example.

```python
from eyepop import EyePopSdk
from eyepop.worker.worker_types import InferenceComponent, Pop

pop = Pop(components=[InferenceComponent(ability="eyepop.person:latest")])

with EyePopSdk.sync_worker(pop=pop) as endpoint:
    ...  # submit a source here
```
Tokens:
Raw