### Start Process with Python

Source: https://docs.processcube.io/clients

Example of initializing the client and starting a process in Python.

```python
from processcube_client import Client
 
client = Client('http://localhost:8000')
result = client.start_process('MyProcess')
```

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

### Start Process with .NET

Source: https://docs.processcube.io/clients

Example of initializing the client and starting a process in .NET.

```csharp
var client = new ProcessCubeClient("http://localhost:8000");
var result = await client.StartProcessAsync("MyProcess");
```

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

### POST /api/install

Source: https://docs.processcube.io/cuby/api

Start an installation of one or more products.

```APIDOC
## POST /api/install

### Description
Installation starten — Body: `{products: [{productId, alias?}]}`.

### Method
POST

### Endpoint
/api/install

### Parameters
#### Request Body
- **products** (array) - Required - List of products to install.
  - **productId** (string) - Required - Identifier of the product.
  - **alias** (string) - Optional - Alias for the installation.

### Request Example
{
  "products": [
    {
      "productId": "processcube-engine"
    }
  ]
}

### Response
#### Success Response (200)
- **instanceId** (string) - Identifier of the installation instance.

#### Response Example
{
  "instanceId": "abc123"
}
```

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

### Quick Start: Install CLI and run engine commands

Source: https://docs.processcube.io/cli

Shows the basic CLI installation and common engine commands: connect to an engine, list process models, start a process, and retry failed instances by piping the output of `lsi` into `retry` with a template placeholder.

```bash
# CLI installieren (Linux/macOS)
curl -fsSL https://marketplace.processcube.io/cli/install | bash
 
# Mit Engine verbinden
pc engine login http://localhost:56000 --root
 
# Prozessmodelle auflisten
pc engine list-process-models
 
# Prozess starten
pc engine start-process-model my_process
 
# Fehlgeschlagene Instanzen erneut versuchen
pc engine lsi --filter-by-state error | pc engine retry {{.processInstanceId}}

```

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

### Start Process with TypeScript

Source: https://docs.processcube.io/clients

Example of initializing the client and starting a process in TypeScript.

```typescript
import { Client } from '@processcube/client';
 
const client = new Client('http://localhost:8000');
const result = await client.startProcess('MyProcess');
```

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

### Setup: Copy .env.example to .env

Source: https://docs.processcube.io/devops/classifier-dashboard

Navigate to the dashboard directory and copy the example environment file to create the local .env configuration.

```bash
cd tools/classifier-dashboard
cp .env.example .env
```

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

### Start install without waiting using --no-wait

Source: https://docs.processcube.io/cuby/cli

Start an install or update without waiting for completion. The CLI returns immediately while the operation continues in the background.

```bash
cuby install processcube-lokal --no-wait
```

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

### Run pc-runtime setup

Source: https://docs.processcube.io/agents/runtime/erste-einrichtung

Starts the interactive setup for pc-runtime. It asks for the desired backend (Claude, Codex, or Hybrid; at least one is required), triggers the necessary logins, sets the default model of agent 'main' to the chosen backend, and finally calls 'main'.

```bash
pc-runtime setup
```

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

### Installation und Start mit NPM

Source: https://docs.processcube.io/engine

Installiert die Engine global über NPM und startet sie. Danach ist die Engine unter http://localhost:10560 erreichbar.

```bash
npm install -g @5minds/processcube_engine
processcube-engine
```

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

### Quickstart: Initialize, add sources, index, and search

Source: https://docs.processcube.io/cli/knowledge

Shows the full workflow: initialize the index, register filesystem and web sources, index/sync, and search with options.

```bash
# Index initialisieren (legt knowledge.config.json + .knowledge/index.sqlite an)
pc knowledge init
 
# Quelle registrieren (Dateipfad oder URL)
pc knowledge add-source filesystem ./docs
pc knowledge add-source web https://example.com/handbook.html
 
# Indizieren
pc knowledge index           # alle Filesystem-Quellen
pc knowledge sync            # zusätzlich Web-Quellen
 
# Suchen
pc knowledge search "timer event"
pc knowledge search "deploy" --source docs --limit 5
pc knowledge search "userTask" -o json | jq '.result.hits[].title'
```

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

### Setup C: Start Node server with hybrid search

Source: https://docs.processcube.io/cli/knowledge

Commands to run on the server machine with Node runtime. Installs sqlite-vec and starts the knowledge server with hybrid search and reranking enabled. This allows all clients, including CLI calls against the server endpoint, to benefit from full hybrid search.

```bash
# Server-Maschine, Node-Runtime
npm install sqlite-vec
node dist/pc.js knowledge serve --hybrid --rerank
```

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

### Set start token from stdin: --start-token-from-stdin

Source: https://docs.processcube.io/cli/engine/start-process-model

Starts a process model with a start token read from STDIN. The example pipes a file to the command.

```bash
cat input.json | pc engine start Registration.EmailCoupons StartEvent_1 --start-token-from-stdin
```

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

### Start der Sample-Extension (npm ci, npm run start)

Source: https://docs.processcube.io/engine/extensions/simple-sample/extension

Startet die Sample-Extension: Wechselt in das Verzeichnis extension/sample-extension/, installiert die Abhängigkeiten mit npm ci und startet eine Engine, die als extensionsDir den sample-Ordner verwendet.

```bash
# Verzeichnis wechseln
cd extension/sample-extension/
# Installieren der abhängigen Pakete
npm ci
# Starten einer Engine, die als extensionsDir den sample-Ordner verwendet
npm run start
```

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

### Verify Engine Installation

Source: https://docs.processcube.io/engine/installation

Commands to verify the installation: start the engine via NPM or run it via Docker. After starting, open http://localhost:10560 to see a JSON response and interactive API documentation (Swagger).

```bash
# NPM
processcube-engine
 
# Docker
docker run -p 10560:80 marketplace.processcube.io/processcube-io/processcube_engine
```

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

### POST /api/setup/complete

Source: https://docs.processcube.io/cuby/api

Mark the setup as complete.

```APIDOC
## POST /api/setup/complete

### Description
Setup als abgeschlossen markieren.

### Method
POST

### Endpoint
/api/setup/complete

### Response
#### Success Response (200)
(No explicit response body documented)
```

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

### Start Engine via NPM

Source: https://docs.processcube.io/engine/installation

Starts the ProcessCube Engine after installation. The engine is then accessible at http://localhost:10560 and uses SQLite by default.

```bash
processcube-engine
```

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

### POST /api/products/start-all

Source: https://docs.processcube.io/cuby/api

Start all configured plugins.

```APIDOC
## POST /api/products/start-all

### Description
Alle konfigurierten Plugins starten.

### Method
POST

### Endpoint
/api/products/start-all

### Response
#### Success Response (200)
(No explicit response body documented)
```

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

### startServer(store, options)

Source: https://docs.processcube.io/knowledge-sdk/plugins

Starts the standalone server with the provided store and optional authentication plugin.

```APIDOC
## startServer(store, options)

### Description
Starts the standalone server with the given store and optional authentication plugin.

### Parameters
- **store** (Store) - Required - The data store to serve.
- **options** (object) - Optional - Configuration options.
  - **auth** (AuthPlugin) - Optional - An authentication plugin to validate requests.

### Example
```typescript
import { startServer } from '@processcube-io/knowledge-sdk/adapters/standalone';
import { createJwtAuth } from './jwt-auth';

await startServer(store, {
  auth: createJwtAuth(process.env.JWT_SECRET!),
});
```
```

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

### Start Dashboard with Bun

Source: https://docs.processcube.io/devops/classifier-dashboard

Install dependencies and start the Next.js development server on port 3100. The dashboard is then available at http://localhost:3100.

```bash
bun install
bun --bun next dev -p 3100
```

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

### Complete config.json example

Source: https://docs.processcube.io/devops/artifact-shipper/configuration

A full example configuration combining all sections: general, credentials, artifacts, targets, and preprocessors.

```json
{
  "general": {
    "logLevel": "info",
    "skipValidation": false
  },
  "credentials": {
    "processcube": {
      "type": "openid",
      "authority": "https://authority.processcube.io",
      "clientId": "artifact-shipper",
      "clientSecret": "secret123"
    },
    "git": {
      "username": "deployment-user",
      "token": "ghp_xxxxxxxxxxxxx"
    }
  },
  "artifacts": [
    {
      "type": "git",
      "repository": "https://github.com/company/processes.git",
      "branch": "main",
      "path": "bpmn",
      "pattern": "**/*.bpmn"
    },
    {
      "type": "local",
      "path": "./flows",
      "pattern": "**/*.json"
    }
  ],
  "targets": [
    {
      "type": "processcube-engine",
      "url": "https://engine.processcube.io",
      "overwriteExisting": true
    },
    {
      "type": "processcube-lowcode",
      "url": "https://lowcode.processcube.io",
      "flowName": "production-flow"
    }
  ],
  "preprocessors": [
    {
      "type": "replace",
      "pattern": "\\$\\{ENV\\}",
      "replacement": "production"
    }
  ]
}
```

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

### GET /api/install/status

Source: https://docs.processcube.io/cuby/api

Query the installation progress for a specific product.

```APIDOC
## GET /api/install/status

### Description
Installationsfortschritt abfragen.

### Method
GET

### Endpoint
/api/install/status

### Parameters
#### Query Parameters
- **productId** (string) - Required - Identifier of the product.

### Response
#### Success Response (200)
- **status** (string) - Current installation status (e.g., "in_progress", "completed").
- **progress** (number) - Installation progress percentage.

#### Response Example
{
  "status": "in_progress",
  "progress": 50
}
```

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

### GET /api/marketplace/products

Source: https://docs.processcube.io/cuby/api

List all available products with installation status and update information.

```APIDOC
## GET /api/marketplace/products

### Description
Alle verfügbaren Produkte mit Installationsstatus und Update-Info.

### Method
GET

### Endpoint
/api/marketplace/products

### Response
#### Success Response (200)
- **products** (array) - List of products, each with installation status and update info.

#### Response Example
{
  "products": [
    {
      "id": "processcube-engine",
      "installed": false,
      "updateAvailable": true
    }
  ]
}
```

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

### Start infrastructure with AppSDK sample app

Source: https://docs.processcube.io/apptemplate/installation

Starts infrastructure services plus the AppSDK sample app, setting the APPSDK_SAMPLE_PORT environment variable.

```bash
APPSDK_SAMPLE_PORT=3000 docker compose up -d postgres engine authority whodb appsdk_sample
```

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

### Feedback-Signal Boost Example

Source: https://docs.processcube.io/knowledge-sdk/klassifikations-pipeline

Example of the feedback signal: if similar tickets were corrected in the past, the corrected collection gets a bonus. Here, the portal collection receives a +2.0 boost.

```text
Ticket: "Dashboard zeigt alte Daten"
FTS5-Suche findet: 5x zu "portal" korrigiert (vorher "lowcode")
→ Boost: portal +2.0
```

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

### Deployen und starten (pc engine deploy/start)

Source: https://docs.processcube.io/blog/agent-runtime-external-task

Deployt das BPMN-Diagramm und startet die Prozess-Instanz mit einem Start-Token. Die Engine legt den External Task an, der Worker holt ihn ab und der Agent antwortet.

```shell
pc engine deploy ./processes/demo.bpmn
pc engine start ai_demo_process StartEvent_1 \
  --start-token '{"aufgabe": "Was ist die Hauptstadt von NRW?"}'
```

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

### Install build tools in Dockerfile for native dependencies

Source: https://docs.processcube.io/lowcode/third-party-nodes/installation

Install native build tools in a Dockerfile when a Node-RED package fails to install due to missing build dependencies. This example uses Alpine Linux's apk package manager.

```dockerfile
# Im Dockerfile zusätzliche Build-Tools installieren
RUN apk add --no-cache python3 make g++
```

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

### GET /wiki

Source: https://docs.processcube.io/cli/knowledge

Wiki browser endpoint, available when the server is started with `--ui`.

```APIDOC
## GET /wiki

### Description
Wiki browser endpoint. Available when the server is started with `--ui`.

### Method
GET

### Endpoint
/wiki

### Response
#### Success Response (200)
- **html** (string) - Wiki browser HTML page.

#### Response Example
{
  "html": "<html>...</html>"
}
```

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

### Setup A: Initialize and search with pc CLI

Source: https://docs.processcube.io/cli/knowledge

Commands for setting up the knowledge base with FTS5 and LLM reranking. Includes setting the VOYAGE_API_KEY, initializing, adding a filesystem source, indexing, and performing a reranked search with JSON output. This setup works in the binary without Node and costs approximately 0.5 cents per query with voyage rerank-2.

```bash
# Einmalig
export VOYAGE_API_KEY=…
pc knowledge init
pc knowledge add-source filesystem ./docs
pc knowledge index
 
# Pro Suche (auch für Agent-Aufrufe)
pc knowledge search "<frage>" --rerank --limit 10 -o json
```

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

### Install .NET Client

Source: https://docs.processcube.io/clients

Install the .NET client using the dotnet CLI.

```bash
dotnet add package ProcessCube.Client
```

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

### Start process and await end event with ProcessDefinitionClient

Source: https://docs.processcube.io/clients/python/api

Creates a process definition client and starts a process instance, waiting for the end event. The example uses the start_event_id and initial_token options.

```python
from processcube_client import ClientFactory
 
factory = ClientFactory()
client = factory.create_process_definition_client("http://localhost:56100")
 
result = client.start_process_instance_and_await_end_event(
    "MeinProzess",
    start_event_id="StartEvent_1",
    initial_token={"eingabe": "wert"}
)
```

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

### Synchronous client usage (core/api)

Source: https://docs.processcube.io/clients/python/api

Synchronous client for non-async contexts like Robot Framework. Shows how to get engine info, start a process with a start event, and deploy BPMN files from a directory.

```python
from processcube_client.core.api.client import Client
 
client = Client("http://localhost:56100")
 
# Engine-Info
info = client.info()
 
# Prozess starten
from processcube_client.core.api.helpers.process_models import ProcessStartRequest
result = client.process_model_start("MeinProzess", ProcessStartRequest(
    start_event_id="StartEvent_1"
))
 
# BPMN-Dateien deployen
result = client.deploy_bpmn_from_path("prozesse/")
```

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

### GET /wiki/log

Source: https://docs.processcube.io/cli/knowledge

Wiki browser endpoint for the wiki log, available when the server is started with `--ui`.

```APIDOC
## GET /wiki/log

### Description
Wiki browser endpoint for the wiki log. Available when the server is started with `--ui`.

### Method
GET

### Endpoint
/wiki/log

### Response
#### Success Response (200)
- **html** (string) - Wiki log HTML.

#### Response Example
{
  "html": "<html>...</html>"
}
```

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

### Initialize and manage knowledge wiki with pc knowledge wiki commands

Source: https://docs.processcube.io/cli/knowledge

Initializes the wiki (creates KNOWLEDGE.md, index.md, log.md) and registers it as a filesystem source. Use `status -o json` to see which index documents are new or changed and await distillation. `lint` acts as a quality gate against drift, exiting with code 1 on findings, suitable for CI/cron. `log` appends a chronological entry with OKF date groups, and `pages` lists pages with markers for stale and orphaned states.

```bash
pc knowledge wiki init
```

```bash
pc knowledge wiki status -o json
```

```bash
pc knowledge wiki lint
```

```bash
pc knowledge wiki log "ingest: timer-events destilliert"
pc knowledge wiki pages --stale --orphaned -o json
```

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

### Node.js not found error

Source: https://docs.processcube.io/cuby/troubleshooting

Error message when the managed Node.js (v22) is not installed, preventing the plugin worker from starting.

```text
Error: Node.js not found
```

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

### Installiere das App-SDK-Paket

Source: https://docs.processcube.io/app-sdk

Installiert das App-SDK-Paket in einem Next.js-Projekt. Führe diesen Befehl im Projektverzeichnis aus, bevor du die SDK-Funktionen importierst.

```bash
npm install @5minds/processcube_app_sdk@latest
```

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

### Examples: pc engine list-manual-tasks

Source: https://docs.processcube.io/cli/engine/list-manual-tasks

Examples of listing manual tasks, filtering by state or process model, and piping the output of `pc engine lsi` into `pc engine lsmt` to get manual tasks of running instances.

```bash
# Alle Manual Tasks auflisten
pc engine list-manual-tasks
 
# Nach Status filtern
pc engine lsmt --filter-by-state running
 
# Nach Prozessmodell filtern
pc engine lsmt --filter-by-process-model-id "Registration"
 
# Piping: Manual Tasks laufender Instanzen
pc engine lsi --filter-by-state running | pc engine lsmt
```

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

### Install with alias and restart using instance ID

Source: https://docs.processcube.io/cuby/cli

Shows how to install a product with an alias, which appends '@test' to the product ID to form the instance ID 'processcube-lokal__test', and then restart using that instance ID.

```bash
cuby install processcube-lokal@test    # Instanz-ID: processcube-lokal__test
cuby restart processcube-lokal__test
```

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

### ESCALATION_START_TOKEN_JQ default and custom examples

Source: https://docs.processcube.io/agents/support

Shows the default jq expression for the escalation start token and a custom example for a process model with different field names. The default matches the provided processes/Support-Escalation.bpmn. A faulty expression aborts the escalation.

```bash
# Default — entspricht dem mitgelieferten processes/Support-Escalation.bpmn
ESCALATION_START_TOKEN_JQ={from:$from, subject:$subject, body:$body, messageId:$messageId, receivedAt:$receivedAt}

# Eigenes Prozessmodell mit anderen Feldnamen
ESCALATION_START_TOKEN_JQ={sender:$from, title:$subject, text:$body, channel:"mail"}
```

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

### Quick install on Windows (PowerShell)

Source: https://docs.processcube.io/cli/installation

Installs the CLI using PowerShell's Invoke-RestMethod and Invoke-Expression. The installer defaults to %USERPROFILE%\.processcube\bin and adds it to PATH without admin rights.

```powershell
powershell -c "irm https://marketplace.processcube.io/cli/install.ps1 | iex"
```

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

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

Source: https://docs.processcube.io/cuby/cli

Use --json to get machine-readable output from all commands, including process and health details. This example pipes the JSON to jq to select instance IDs whose status is not ok.

```bash
cuby list --json | jq -r '.[] | select(.status != "ok") | .instanceId'
```

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

### Manual installation via git clone and cp

Source: https://docs.processcube.io/agent-skills

Manual installation: clone the repository and copy the desired skill directory (e.g., repo-doku) into the project's .claude/skills/ directory. Adjust the destination path for other agents like ~/.openclaw/skills/.

```bash
git clone https://github.com/processcube-io/ProcessCube.Agent.Skills.git
cp -r ProcessCube.Agent.Skills/skills/repo-doku /pfad/zum/projekt/.claude/skills/
```

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

### REST-Server starten (pc knowledge serve)

Source: https://docs.processcube.io/cli/knowledge

Startet den REST-Server. Ohne Optionen bindet er an 127.0.0.1:51344. Mit --port und --host lässt sich Interface und Port anpassen.

```bash
pc knowledge serve
```

```bash
pc knowledge serve --port 8080 --host 0.0.0.0
```

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

### GET /api/config

Source: https://docs.processcube.io/cuby/api

Retrieve the current configuration including installed products, API key status, operator mode, and version.

```APIDOC
## GET /api/config

### Description
Aktuelle Konfiguration inkl. installierter Produkte, API-Key-Status, Operator-Modus und Version.

### Method
GET

### Endpoint
/api/config

### Response
#### Success Response (200)
- **products** (array) - List of installed products
- **apiKeyStatus** (string) - Status of the API key (e.g., valid, invalid)
- **operatorMode** (boolean) - Whether operator mode is enabled
- **version** (string) - Version of the server

#### Response Example
{
  "products": [],
  "apiKeyStatus": "valid",
  "operatorMode": false,
  "version": "1.0.0"
}
```

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

### Installation des KnowledgeSDK Pakets

Source: https://docs.processcube.io/knowledge-sdk/als-library

Installiert das Paket @processcube-io/knowledge-sdk über npm. Das Paket wird über den ProcessCube Marketplace verteilt; die Registry-Konfiguration ist in der Installationsanleitung zu finden.

```bash
npm install @processcube-io/knowledge-sdk
```

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

### GET /wiki/p/{path}

Source: https://docs.processcube.io/cli/knowledge

Wiki browser endpoint for a specific page path, available when the server is started with `--ui`.

```APIDOC
## GET /wiki/p/{path}

### Description
Wiki browser endpoint for a specific page path. Available when the server is started with `--ui`.

### Method
GET

### Endpoint
/wiki/p/{path}

### Parameters
#### Path Parameters
- **path** (string) - Required - Page path.

### Response
#### Success Response (200)
- **html** (string) - Wiki page HTML.

#### Response Example
{
  "html": "<html>...</html>"
}
```

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

### Install .NET client NuGet packages

Source: https://docs.processcube.io/clients/dotnet

Commands to add the main client, hosting integration, and OAuth 2.0 authentication packages via dotnet CLI.

```bash
# Haupt-Client
dotnet add package ProcessCube.Engine.Client
 
# Mit .NET Generic Host Integration
dotnet add package ProcessCube.Engine.Client.Extensions.Hosting
 
# Mit OAuth 2.0 Authentifizierung
dotnet add package ProcessCube.Engine.Client.Extensions.OAuth20
```

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

### Set Application Port Only

Source: https://docs.processcube.io/authority/configuration

Example showing how to set the applicationPort, which determines the port on which the Authority's HTTP server starts.

```json
{
  "applicationPort": 11560
}
```