Qelos

https://docs.qelos.io
Admin
Qelos is an AI-first application layer gateway that provides REST APIs, AI agents, authentication,...
Tokens:256,186
Snippets:2,923
Trust Score:5.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### Post-creation setup commands

Source: https://docs.qelos.io/cli/create

Standard workflow commands to navigate to the project, install dependencies, and start the development server.

```bash
cd my-awesome-plugin
```

```bash
npm install
```

```bash
npm run dev
```

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

### Quick start and common CLI operations

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

Installation, environment setup, and common commands for managing components, blueprints, and AI agents.

```bash
# Install the CLI
npm install -g @qelos/cli

# Set up a .env file for your instance
echo 'QELOS_URL=https://my-instance.qelos.app' > .env
echo 'QELOS_USERNAME=admin@company.com' >> .env
echo 'QELOS_PASSWORD=secret' >> .env

# Create a new plugin
qplay create my-plugin

# Pull components from your Qelos instance
qelos pull components ./my-components

# Pull blueprints
qelos pull blueprints ./my-blueprints

# Pull configurations
qelos pull config ./my-configs

# Pull integrations & connections
qelos pull integrations ./my-integrations
qelos pull connections ./my-connections

# Generate IDE rules for better AI assistance
qelos generate rules all

# Preview what will be pushed
qelos get staged .
qelos get committed .

# Make changes locally

# Push changes back to Qelos
qelos push components ./my-components
qelos push blueprints ./my-blueprints
qelos push config ./my-configs
qelos push integrations ./my-integrations
qelos push connections ./my-connections

# Push with hard flag to remove remote resources that don't exist locally
qelos push components ./my-components --hard
qelos push all ./my-project --hard

# Push to a different environment using --env
qelos --env production push components ./my-components

# Invoke the SDK directly
qelos sdk blueprints getList
qelos sdk blueprints entitiesOf todo create '{"title":"Buy milk"}'
echo '{"done":false}' | qelos sdk entities todo getList

# Interact with AI agents
qelos agent code-wizard --message "Hello, how can you help me?"
echo "What's the weather?" | qelos agent weather-agent --stream
qelos agent assistant --log conversation.json --export response.md

# Save agent preferences for reuse
qelos agent code-wizard --stream --log chat.json --save
qelos agent code-wizard -m "Hello"  # uses saved defaults
```

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

### Complete SDK Setup Example

Source: https://docs.qelos.io/sdk/core_functionality

A full workflow demonstrating initialization, header configuration, user sign-in, and module usage.

```typescript
import QelosSDK from '@qelos/sdk';

// Initialize the SDK
const sdk = new QelosSDK({
  appUrl: 'https://your-qelos-app.com',
  fetch: globalThis.fetch,
  forceRefresh: true,
});

// Add custom headers for tracking
sdk.setCustomHeader('X-Client-Version', '1.0.0');
sdk.setCustomHeader('X-Client-Platform', 'web');

// Authenticate the user
await sdk.authentication.oAuthSignin({
  username: 'user@example.com',
  password: 'password'
});

// Now you can use any of the SDK modules
const workspaces = await sdk.workspaces.getList();
const userProfile = await sdk.authentication.getLoggedInUser();
```

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

### Navigate and install dependencies

Source: https://docs.qelos.io/plugins/create

Enter the newly created directory and install the required project dependencies.

```shell
cd my-new-plugin
npm install
```

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

### Run Qelos locally

Source: https://docs.qelos.io/

Commands to clone the repository, install dependencies, build the project, and start the development environment.

```bash
git clone https://github.com/qelos-io/qelos.git
cd qelos
pnpm install      # install dependencies
pnpm build        # build packages
pnpm dev          # start the dev environment (includes MongoDB)
pnpm populate-db  # seed initial data (in a new terminal)
```

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

### Basic Usage Example

Source: https://docs.qelos.io/pre-designed-frontends/components/q-pre

A minimal example showing the component with a static string.

```html
<q-pre value="Hello World"></q-pre>
```

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

### Complete Webhook Execution Example

Source: https://docs.qelos.io/sdk/execute_lambdas

A full implementation example showing SDK initialization and a POST request to trigger a webhook.

```typescript
import { QelosSDK } from '@qelos/sdk';

const sdk = new QelosSDK({ 
  apiKey: process.env.QELOS_API_KEY,
  baseUrl: 'https://api.qelos.io'
});

// Trigger a webhook with POST data
const response = await sdk.lambdas.post('webhook-integration-id', {
  body: {
    event: 'user.created',
    userId: '12345',
    email: 'user@example.com'
  }
});

console.log('Webhook response:', response);
```

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

### Install TypeScript Dependencies

Source: https://docs.qelos.io/plugin-play/installation

Install TypeScript and initialize the configuration file.

```bash
npm install --save-dev typescript @types/node
npx tsc --init
```

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

### Start Development Server

Source: https://docs.qelos.io/plugin-play/installation

Launches the plugin in development mode.

```bash
npm run dev
```

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

### Install Plugin Play

Source: https://docs.qelos.io/plugin-play/installation

Install the core Plugin Play package.

```bash
npm install @qelos/plugin-play
```

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

### Install Qelos Next.js Integrator

Source: https://docs.qelos.io/integrators/next

Install the required packages via npm.

```bash
npm install @qelos/integrator-next @qelos/sdk
```

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

### Connection Configuration Example

Source: https://docs.qelos.io/cli/push

Example JSON structure for a connection file using an environment variable for authentication.

```json
{
  "_id": "64f1c1e5c3f2",
  "name": "OpenAI",
  "kind": "openai",
  "labels": ["ai", "default"],
  "metadata": { "defaultModel": "gpt-4o" },
  "authentication": {
    "$var": "INTEGRATION_AUTH_OPENAI"
  }
}
```

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

### Install Qelos Web SDK

Source: https://docs.qelos.io/web-sdk

Commands to install the SDK using common package managers.

```bash
npm install @qelos/web-sdk
# or
yarn add @qelos/web-sdk
# or
pnpm add @qelos/web-sdk
```

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

### Start the development server

Source: https://docs.qelos.io/getting-started/installation

Launches the local development server for testing.

```bash
pnpm dev
```

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

### Install Integrator Packages

Source: https://docs.qelos.io/getting-started/integrators

Commands to install the required integrator package and SDK for your framework.

```bash
npm install @qelos/integrator-express @qelos/sdk
```

```bash
npm install @qelos/integrator-next @qelos/sdk
```

```bash
npm install @qelos/integrator-nuxt
```

```bash
npm install @qelos/integrator-fastify @qelos/sdk
```

```bash
npm install @qelos/integrator-nest @qelos/sdk
```

```bash
pip install qelos-integrator-fastapi qelos-sdk
```

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

### SDK Mapping Examples

Source: https://docs.qelos.io/cli/sdk

Examples showing the translation from TypeScript SDK calls to CLI commands.

```bash
qelos sdk blueprints getList
```

```bash
qelos sdk blueprints entitiesOf todo getList
```

```bash
qelos sdk blueprints entitiesOf todo create '{"title":"Buy milk"}'
```

```bash
qelos sdk entities todo getList '{"status":"open"}'
```

```bash
qelos sdk users getList '{"username":"ada"}'
```

```bash
qelos sdk events getList '{"kind":"auth"}'
```

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

### Install Development Dependencies

Source: https://docs.qelos.io/plugin-play/installation

Installs the necessary tools for running the plugin in a development environment.

```bash
npm install --save-dev tsx nodemon
```

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

### Install Qelos Integrator

Source: https://docs.qelos.io/getting-started/intro

Installs the framework-specific integrator package.

```bash
npm install @qelos/integrator-next
```

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

### Basic Remove Button Implementation

Source: https://docs.qelos.io/pre-designed-frontends/components/remove-button

Full example including script setup for handling the removal logic and loading state.

```html
<script setup>
const isRemoving = ref(false)

async function handleRemove() {
  isRemoving.value = true
  try {
    await deleteItem(itemId)
    ElMessage.success('Item removed successfully')
  } finally {
    isRemoving.value = false
  }
}
</script>

<template>
  <remove-button 
    @remove="handleRemove"
    :loading="isRemoving"
  />
</template>
```

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

### Install Qelos Express Integrator

Source: https://docs.qelos.io/integrators/express

Install the necessary packages via npm.

```bash
npm install @qelos/integrator-express @qelos/sdk
# express is a peer dependency
npm install express
```

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

### Install the Qelos FastAPI package

Source: https://docs.qelos.io/integrators/fastapi

Install the required integrator and SDK packages via pip.

```bash
pip install qelos-integrator-fastapi qelos-sdk
```

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

### Verify CLI installation

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

Check the installed version using the qelos or qplay command aliases.

```bash
qelos --version
qplay --version
```

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

### Basic Confirmation Example

Source: https://docs.qelos.io/pre-designed-frontends/components/confirm-message

A complete example showing the component integrated with a button trigger and handler function.

```html
<script setup>
const showDialog = ref(false)

function deleteItem() {
  showDialog.value = true
}

function handleConfirm() {
  // Perform delete action
  console.log('Item deleted')
}
</script>

<template>
  <el-button @click="deleteItem" type="danger">
    Delete Item
  </el-button>
  
  <confirm-message 
    v-model="showDialog"
    message="This action cannot be undone. Are you sure?"
    type="danger"
    @confirm="handleConfirm"
  />
</template>
```

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

### Install Qelos CLI globally

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

Use npm to install the CLI package globally on your system.

```bash
npm install -g @qelos/cli
```

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

### Basic Usage of qelos get

Source: https://docs.qelos.io/cli/get

Standard syntax for executing the get command with required type and path arguments.

```bash
qelos get <type> <path> [options]
```

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

### Multi-Step Workflows

Source: https://docs.qelos.io/pre-designed-frontends/components/callback-link

Example implementation for navigating between steps in a multi-step workflow.

```html
<callback-link url="https://my-plugin-url.com/second-step">
  Continue to Next Step
</callback-link>
```

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

### Install dependencies

Source: https://docs.qelos.io/integrators/nest

Install the required Qelos integrator and SDK packages along with NestJS peer dependencies.

```bash
npm install @qelos/integrator-nest @qelos/sdk
# Nest is a peer dependency
npm install @nestjs/common @nestjs/core
```

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

### Install or upgrade Qelos via Helm

Source: https://docs.qelos.io/deployment/kubernetes-cluster-management

Deploy the application using Helm charts or perform an upgrade on an existing installation.

```bash
# Install Qelos in the qelos namespace
helm install qelos ./helm/qelos \
  -f ./helm/qelos/values-production.yaml \
  --namespace qelos \
  --create-namespace

# Or upgrade if already installed
helm upgrade --install qelos ./helm/qelos \
  -f ./helm/qelos/values-production.yaml \
  --namespace qelos
```

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

### Retrieve Public Plans

Source: https://docs.qelos.io/api/payments

Example response for the GET /api/plans/public endpoint.

```json
[
  {
    "_id": "plan_id",
    "name": "Pro",
    "monthlyPrice": 29,
    "yearlyPrice": 290,
    "currency": "USD",
    "dynamic": false,
    "isActive": true
  }
]
```

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

### Get Count Response

Source: https://docs.qelos.io/api/blueprints

Example JSON response for an entity count.

```json
{
  "count": 42
}
```

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

### Build and Start Production Application

Source: https://docs.qelos.io/plugin-play/installation

Commands to compile the project and initiate the production server.

```bash
npm run build
npm start
```

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

### Get Sum Responses

Source: https://docs.qelos.io/api/blueprints

Example JSON responses for sum operations with and without grouping.

```json
{
  "groups": [
    { "group": "North", "sum": 15000 },
    { "group": "South", "sum": 12000 }
  ],
  "sum": 27000
}
```

```json
{
  "sum": 27000
}
```

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

### View help options

Source: https://docs.qelos.io/cli/create

Display all available options for the create command.

```bash
qplay create --help
```

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

### qelos get

Source: https://docs.qelos.io/cli/get

Preview files that would be pushed to your Qelos instance.

```APIDOC
## CLI Command: qelos get

### Description
The `get` command allows you to preview files that would be pushed to your Qelos instance without actually pushing them. It categorizes files by type and displays dependencies.

### Usage
`qelos get <type> <path> [options]`

### Arguments
- **type** (Required) - The category of files to retrieve (e.g., components, blueprints, plugins, committed, staged, all).
- **path** (Required) - The base directory path to search for resources.

### Options
- **--json, -j** (Optional) - Output results in JSON format.
- **--verbose, -V** (Optional) - Enable verbose logging with debug information.
```

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

### Get Workspace Response

Source: https://docs.qelos.io/api/workspaces

Example JSON response for a single workspace, including members and invites arrays.

```json
{
  "_id": "workspace-id",
  "name": "My Workspace",
  "logo": "https://example.com/logo.png",
  "labels": ["team"],
  "members": [],
  "invites": []
}
```

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

### Basic Rating Implementation

Source: https://docs.qelos.io/pre-designed-frontends/components/q-rating

A complete Vue component example showing script setup and template usage.

```html
<script setup>
const rating = ref(0)

function handleRatingChange(newRating) {
  console.log('New rating:', newRating)
}
</script>

<template>
  <q-rating 
    v-model="rating"
    @change="handleRatingChange"
  />
</template>
```

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

### Project Setup CLI Commands

Source: https://docs.qelos.io/getting-started/quick-reference

Commands for initializing plugins, blueprints, and managing remote resources.

```bash
# Create new plugin
qelos create plugin my-plugin

# Create new blueprint
qelos create blueprint Product

# Generate CRUD with UI
qelos generate crud Product --with-listing --with-forms

# Pull remote resources
qelos pull

# Push changes
qelos push
```

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

### Complete Configuration Management Example

Source: https://docs.qelos.io/sdk/managing_configurations

Demonstrates the full lifecycle of managing configurations using the Admin SDK.

```typescript
import QelosAdminSDK from '@qelos/sdk/administrator';

// Initialize the admin SDK
const sdkAdmin = new QelosAdminSDK({
  appUrl: 'https://your-qelos-app.com',
  fetch: globalThis.fetch
});

// Authenticate as admin
await sdkAdmin.authentication.oAuthSignin({
  username: 'admin@example.com',
  password: 'password'
});

// Get all configurations
const configurations = await sdkAdmin.manageConfigurations.getList();
console.log(`Found ${configurations.length} configurations`);

// Create a new configuration
await sdkAdmin.manageConfigurations.create({
  key: 'email-settings',
  public: false,
  description: 'Email service configuration',
  metadata: {
    smtpHost: 'smtp.example.com',
    smtpPort: 587,
    fromEmail: 'noreply@example.com'
  }
});

// Get specific configuration
const emailConfig = await sdkAdmin.manageConfigurations.getConfiguration('email-settings');
console.log('Email config:', emailConfig.metadata);

// Update configuration
await sdkAdmin.manageConfigurations.update('email-settings', {
  metadata: {
    smtpHost: 'smtp.newprovider.com',
    smtpPort: 465,
    fromEmail: 'noreply@example.com'
  }
});

// Remove configuration
await sdkAdmin.manageConfigurations.remove('email-settings');
console.log('Configuration removed');
```

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

### Basic Usage Example

Source: https://docs.qelos.io/pre-designed-frontends/components/quick-table

A simple implementation with inline column definitions.

```html
<quick-table :data="users" :columns="[
  { prop: 'name', label: 'Name' },
  { prop: 'email', label: 'Email' },
  { prop: 'role', label: 'Role' }
]"></quick-table>
```

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

### Consuming Injected Dependencies

Source: https://docs.qelos.io/getting-started/admin-architecture

Example of accessing and reacting to injected dependencies within a Vue component setup script.

```vue
<script setup>
import { inject } from 'vue'

// Access injected dependencies
const user = inject('user')
const appConfig = inject('appConfig')
const wsConfig = inject('wsConfig')

// Use the reactive data
watchEffect(() => {
  console.log('Current user:', user.value)
  console.log('App config:', appConfig.value)
})
</script>
```

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

### Get Workspace Members Response

Source: https://docs.qelos.io/api/workspaces

Example JSON response containing an array of member objects with their roles and creation timestamps.

```json
[
  {
    "user": "user-id",
    "roles": ["admin"],
    "created": "2025-01-01T00:00:00.000Z"
  }
]
```

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

### Basic Usage Example

Source: https://docs.qelos.io/pre-designed-frontends/components/empty-state

A minimal implementation of the empty state component.

```html
<empty-state 
  title="No Results Found" 
  description="Try adjusting your search criteria."
></empty-state>
```

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

### Example .env Files

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

Sample content for .env files using either API tokens or username/password authentication.

```bash
QELOS_URL=https://my-instance.qelos.app
QELOS_API_TOKEN=ql_your_api_token_here
```

```bash
QELOS_URL=https://my-instance.qelos.app
QELOS_USERNAME=admin@company.com
QELOS_PASSWORD=secret
```

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

### Payments SDK Quick Start

Source: https://docs.qelos.io/payments

Demonstrates initializing the SDK, listing plans, and handling both static and dynamic plan checkout flows.

```typescript
import { QelosSDK } from '@qelos/sdk';
import { QelosAdministratorSDK } from '@qelos/sdk/administrator';

const sdk = new QelosSDK({ baseUrl: 'https://your-app.com' });
const adminSdk = new QelosAdministratorSDK({ baseUrl: 'https://your-app.com' });

// List available plans
const plans = await sdk.payments.getPlans({ isActive: true });

// Static plan — subscribe and pay in one step
const { checkoutUrl } = await sdk.payments.checkout({
  planId: 'plan-id',
  billingCycle: 'monthly',
  successUrl: 'https://myapp.com/success',
});
window.location.href = checkoutUrl;

// Dynamic plan — two-phase flow
const sub = await sdk.payments.subscribeToPlan('dynamic-plan-id', 'monthly');
// Admin sets the amount:
await adminSdk.managePayments.setSubscriptionDynamicAmount(sub._id, 149.00);
// User initiates checkout:
const { checkoutUrl: url } = await sdk.payments.checkout({ subscriptionId: sub._id });
window.location.href = url;
```

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

### Define a standard Vue component

Source: https://docs.qelos.io/getting-started/component-guide

A comprehensive example of a Vue component using script setup, props validation, emits, computed properties, and scoped CSS.

```vue
<!-- components/MyComponent.vue -->
<script setup>
import { computed, ref } from 'vue'

// Props definition
const props = defineProps({
  // Basic props
  title: {
    type: String,
    required: true
  },
  
  // Prop with default
  size: {
    type: String,
    default: 'medium',
    validator: (value) => ['small', 'medium', 'large'].includes(value)
  },
  
  // Complex prop
  config: {
    type: Object,
    default: () => ({
      showHeader: true,
      bordered: false
    })
  }
})

// Emits definition
const emit = defineEmits([
  'update',      // For v-model
  'click',
  'custom-event'
])

// Local state
const isActive = ref(false)
const count = ref(0)

// Computed properties
const sizeClass = computed(() => `my-component--${props.size}`)
const hasHeader = computed(() => props.config.showHeader && props.title)

// Methods
const handleClick = () => {
  isActive.value = !isActive.value
  emit('click', { active: isActive.value })
}

const increment = () => {
  count.value++
  emit('update', count.value)
}

// Watchers
watch(count, (newVal) => {
  if (newVal > 10) {
    emit('custom-event', { count: newVal })
  }
})

// Lifecycle
onMounted(() => {
  console.log('Component mounted')
})
</script>

<template>
  <div 
    :class="['my-component', sizeClass]"
    :class="{ 'is-active': isActive }"
    @click="handleClick"
  >
    <!-- Conditional header -->
    <header v-if="hasHeader" class="my-component__header">
      <h3>{{ title }}</h3>
      <slot name="header-extra" />
    </header>
    
    <!-- Default slot -->
    <main class="my-component__body">
      <slot>
        Default content when no slot provided
      </slot>
    </main>
    
    <!-- Named slots -->
    <footer v-if="$slots.footer" class="my-component__footer">
      <slot name="footer" />
    </footer>
  </div>
</template>

<style scoped>
.my-component {
  /* Use design tokens */
  background: var(--qelos-surface);
  border: 1px solid var(--qelos-border);
  border-radius: var(--qelos-border-radius);
  padding: var(--qelos-spacing-md);
  transition: all 0.3s ease;
}

.my-component:hover {
  border-color: var(--qelos-primary);
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
}

.my-component.is-active {
  background: var(--qelos-primary-light);
  border-color: var(--qelos-primary);
}

/* Size modifiers */
.my-component--small {
  padding: var(--qelos-spacing-sm);
}

.my-component--large {
  padding: var(--qelos-spacing-lg);
}

/* Dark mode support */
@media (prefers-color-scheme: dark) {
  .my-component {
    background: var(--qelos-surface-dark);
    border-color: var(--qelos-border-dark);
  }
}
</style>
```

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

### Complete Invites Module Usage Example

Source: https://docs.qelos.io/sdk/managing_invites

Demonstrates initializing the SDK, authenticating, and iterating through invites to accept them.

```typescript
import { QelosSDK } from '@qelos/sdk';

// Initialize the SDK
const sdk = new QelosSDK({
  appUrl: 'https://your-qelos-app.com',
});

// Authenticate the user
await sdk.authentication.oAuthSignin({
  username: 'user@example.com',
  password: 'password'
});

// Get all invites for the current user
const invites = await sdk.invites.getList();

// Process each invite
invites.forEach(async (invite) => {
  const workspaceId = invite.workspace._id;
  
  // Accept the invitation
  // You could implement your own logic to determine whether to accept or decline
  await sdk.invites.acceptWorkspace(workspaceId);
  
  // Or decline the invitation
  // await sdk.invites.declineWorkspace(workspaceId);
});
```

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

### Create New Entity Implementation

Source: https://docs.qelos.io/pre-designed-frontends/components/blueprint-entity-form

Example showing how to handle entity creation with a success callback and navigation.

```html
<script setup>
function handleSaved(entity) {
  ElMessage.success('Product created successfully!')
  router.push(`/products/${entity._id}`)
}
</script>

<template>
  <blueprint-entity-form 
    blueprint="products"
    @saved="handleSaved"
    @cancelled="() => router.push('/products')"
  />
</template>
```

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

### Initialize a new plugin project

Source: https://docs.qelos.io/cli/create

Use these commands to scaffold a new plugin project directory.

```bash
qplay create <project-name>
```

```bash
qelos create <project-name>
```

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

### Initialize Web SDK

Source: https://docs.qelos.io/web-sdk

Minimal example showing how to authorize a session and access user data.

```typescript
import { authorize, code } from '@qelos/web-sdk';

// Initialize authentication
const userData = await authorize();
console.log('Current user:', userData);
console.log('Session code:', code);

// Your application code here
```

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

### Create Plugin from Template

Source: https://docs.qelos.io/getting-started/design-products-faster

Initializes a new plugin project using a pre-defined SaaS starter template.

```bash
# Start from proven templates
qelos create plugin --template=saas-starter
```

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

### Basic Usage Example

Source: https://docs.qelos.io/pre-designed-frontends/components/monaco

A simple example of binding a JavaScript variable to the editor.

```html
<monaco v-model="javascriptCode" language="javascript"></monaco>
```

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

### Integrate Qelos into an existing application

Source: https://docs.qelos.io/

Commands to install the CLI, initialize the project, and add the necessary framework integrator and SDK.

```bash
# 1. Install the CLI
npm install -g @qelos/cli

# 2. Initialize in your project (detects framework, scaffolds config)
qelos init

# 3. Install the integrator for your framework
npm install @qelos/integrator-next   # or express, nuxt, fastify, nest

# 4. Install the SDK
npm install @qelos/sdk
```

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

### Create a new plugin example

Source: https://docs.qelos.io/cli/create

Basic command to generate a plugin named my-awesome-plugin.

```bash
# Create a new plugin called "my-awesome-plugin"
qplay create my-awesome-plugin
```

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

### Initialize Form with Data

Source: https://docs.qelos.io/pre-designed-frontends/components/blueprint-entity-form

Example showing how to pre-populate the form using the initial-data prop.

```html
<script setup>
const initialProduct = {
  name: 'New Product',
  category: 'electronics',
  price: 99.99
}
</script>

<template>
  <blueprint-entity-form 
    blueprint="products"
    :initial-data="initialProduct"
    @saved="handleSaved"
  />
</template>
```

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

### Install Ingress Controller

Source: https://docs.qelos.io/deployment/kubernetes-cluster-management

Helm commands to install NGINX or Traefik ingress controllers.

```bash
# Install using Helm
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

helm install nginx-ingress ingress-nginx/ingress-nginx \
  --namespace ingress-nginx \
  --create-namespace \
  --set controller.service.type=LoadBalancer
```

```bash
helm repo add traefik https://helm.traefik.io/traefik
helm repo update

helm install traefik traefik/traefik \
  --namespace traefik \
  --create-namespace
```

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

### Initialize and Use Qelos SDK

Source: https://docs.qelos.io/getting-started/intro

Demonstrates initializing the SDK with environment variables and performing entity lookups and AI agent interactions.

```typescript
import QelosSDK from '@qelos/sdk';

const sdk = new QelosSDK({
  appUrl: process.env.QELOS_APP_URL!,
  apiToken: process.env.QELOS_API_TOKEN!,
});

const products = await sdk.entities('products').find({ status: 'active' });
const reply = await sdk.ai.agents.chat('agent-id', 'How can I help?');
```

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

### Configure Environment Variables

Source: https://docs.qelos.io/plugin-play/installation

Example .env file containing connection and security settings.

```bash
# Qelos Connection
QELOS_URL=https://your-qelos-app.com
QELOS_USERNAME=plugin-user@example.com
QELOS_PASSWORD=your-password

# Server Configuration
PORT=3000
HOST=0.0.0.0
NODE_ENV=development

# Security (generate secure random strings)
REFRESH_TOKEN_SECRET=your-refresh-token-secret
ACCESS_TOKEN_SECRET=your-access-token-secret
USER_PAYLOAD_SECRET=your-user-payload-secret

# Optional: Redis for caching
REDIS_URL=redis://localhost:6379

# Optional: Static files
STATIC_ROOT=public
STATIC_PREFIX=/
```

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

### Install project dependencies

Source: https://docs.qelos.io/getting-started/installation

Installs all required npm packages in the project root directory.

```bash
pnpm install
```

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

### GET /api/webhooks/{integrationId}

Source: https://docs.qelos.io/api/webhooks

Executes a webhook or lambda function using the GET method.

```APIDOC
## GET /api/webhooks/{integrationId}

### Description
Execute a webhook or lambda function using GET.

### Method
GET

### Endpoint
/api/webhooks/{integrationId}

### Parameters
#### Path Parameters
- **integrationId** (string) - Required - The integration identifier
```

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

### Initialize Qelos SDKs

Source: https://docs.qelos.io/sdk/payments

Setup the standard and administrator SDK instances with the base URL of your Qelos instance.

```typescript
import { QelosSDK } from '@qelos/sdk';
import { QelosAdministratorSDK } from '@qelos/sdk/administrator';

const sdk = new QelosSDK({ baseUrl: 'https://your-qelos-instance.com' });
const adminSdk = new QelosAdministratorSDK({ baseUrl: 'https://your-qelos-instance.com' });
```

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

### Initialize a new plugin project

Source: https://docs.qelos.io/plugins/create

Use the play CLI to scaffold a new plugin directory.

```shell
npm init play@latest my-new-plugin
```

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

### Execute Webhook via GET

Source: https://docs.qelos.io/api/webhooks

Trigger a lambda function using the GET method.

```http
GET /api/webhooks/{integrationId}
```

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

### Install the Nuxt Integrator

Source: https://docs.qelos.io/integrators/nuxt

Install the package via npm to add it as a dependency to your Nuxt project.

```bash
npm install @qelos/integrator-nuxt
```

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

### Initialize Qelos Project

Source: https://docs.qelos.io/getting-started/intro

Scaffolds the Qelos configuration within an existing project.

```bash
qelos init
```

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

### Complete blocks module usage example

Source: https://docs.qelos.io/sdk/managing_blocks

Demonstrates SDK initialization, authentication, and full CRUD lifecycle for a block.

```typescript
import { QelosSDK } from '@qelos/sdk';

// Initialize the SDK
const sdk = new QelosSDK({
  appUrl: 'https://your-qelos-app.com',
});

// Authenticate the user
await sdk.authentication.oAuthSignin({
  username: 'user@example.com',
  password: 'password'
});

// Get all blocks
const blocks = await sdk.blocks.getList();
console.log(`Found ${blocks.length} blocks`);

// Create a new block
const headerBlock = await sdk.blocks.create({
  name: "Header",
  description: "Main site header with navigation",
  content: `
    <header>
      <nav>
        <ul>
          <li><a href="/">Home</a></li>
          <li><a href="/about">About</a></li>
          <li><a href="/contact">Contact</a></li>
        </ul>
      </nav>
    </header>
  `,
  contentType: "html"
});

console.log(`Created new block with ID: ${headerBlock._id}`);

// Update the block
const updatedBlock = await sdk.blocks.update(headerBlock._id, {
  content: `
    <header>
      <nav>
        <ul>
          <li><a href="/">Home</a></li>
          <li><a href="/about">About</a></li>
          <li><a href="/contact">Contact</a></li>
          <li><a href="/blog">Blog</a></li>
        </ul>
      </nav>
    </header>
  `
});

console.log(`Updated block with new content`);
```

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

### Initialize New Project

Source: https://docs.qelos.io/plugin-play/installation

Commands to create a new directory and initialize a Node.js project.

```bash
mkdir my-qelos-plugin
cd my-qelos-plugin
npm init -y
```

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

### Install Fastify Integrator

Source: https://docs.qelos.io/integrators/fastify

Install the required packages via npm. Fastify is a peer dependency.

```bash
npm install @qelos/integrator-fastify @qelos/sdk
# fastify is a peer dependency
npm install fastify
```

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

### Initialize SDK in Vanilla JavaScript

Source: https://docs.qelos.io/web-sdk/installation

Basic implementation using ES modules within an HTML file.

```html
<!DOCTYPE html>
<html>
<head>
    <title>My Micro-Frontend</title>
</head>
<body>
    <div id="app">
        <h1>Loading...</h1>
    </div>

    <script type="module">
        import { authorize, code } from '@qelos/web-sdk';

        // Initialize authentication
        const userData = await authorize();
        
        document.getElementById('app').innerHTML = `
            <h1>Welcome, ${userData.user.fullName}!</h1>
            <p>Session Code: ${code}</p>
        `;
    </script>
</body>
</html>
```

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

### Initialize Qelos AI SDK

Source: https://docs.qelos.io/sdk/ai_sdk_structure

Setup the main SDK instance with authentication and configuration before accessing sub-SDKs.

```typescript
import QelosSDK from '@qelos/sdk';

const sdk = new QelosSDK({
  appUrl: 'https://your-qelos-instance.com',
  fetch: globalThis.fetch,
  accessToken: 'your-access-token'
});

// Access AI functionality through sub-SDKs
await sdk.ai.threads.create({ integration: 'id' });
await sdk.ai.chat.stream('id', options);
await sdk.ai.rag.uploadContent('sourceId', data);
```

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

### Initialize Admin SDK

Source: https://docs.qelos.io/sdk/sdk_reference

Configure the QelosAdminSDK instance with the application URL and fetch implementation.

```typescript
import QelosAdminSDK from '@qelos/sdk/administrator';

const sdkAdmin = new QelosAdminSDK({
  appUrl: 'https://your-app.qelos.app',
  fetch: globalThis.fetch,
});
await sdkAdmin.authentication.oAuthSignin({ username, password });
```

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

### Prepare Helm values

Source: https://docs.qelos.io/deployment/kubernetes-cluster-management

Initialize the production configuration file from the provided template.

```bash
cp helm/qelos/values.yaml.github.tpl helm/qelos/values-production.yaml
# Edit values-production.yaml with your configuration
```

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

### Analyze and Recommend Resources

Source: https://docs.qelos.io/deployment/kubernetes-cluster-management

Use these commands to inspect current pod resource consumption and retrieve VPA recommendations.

```bash
# Analyze resource usage
kubectl top pods -n qelos --containers

# Use Vertical Pod Autoscaler (VPA) for recommendations
kubectl describe vpa vpa-name -n qelos
```

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

### Initialize and Use Qelos SDK

Source: https://docs.qelos.io/sdk/sdk

Initialize the SDK with your application URL and fetch implementation, then authenticate and perform operations.

```typescript
import QelosSDK from '@qelos/sdk';

// Initialize the SDK
const sdk = new QelosSDK({
  appUrl: 'https://your-qelos-app.com',
  fetch: globalThis.fetch, // Required: provide fetch implementation
  forceRefresh: true, // Enable automatic token refresh
});

// Authenticate the user
await sdk.authentication.oAuthSignin({
  username: 'user@example.com',
  password: 'password'
});

// Now you can use the SDK to interact with Qelos
const workspaces = await sdk.workspaces.getList();
const userProfile = await sdk.authentication.getLoggedInUser();

// Use AI capabilities
const thread = await sdk.ai.createThread({
  integration: 'your-ai-integration-id',
  title: 'Customer Support Chat'
});

const response = await sdk.ai.chat('your-ai-integration-id', {
  messages: [{ role: 'user', content: 'Hello!' }]
});
```

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

### User Header JSON Example

Source: https://docs.qelos.io/cli/generate-proxy

An example of the JSON-string format used in the 'user' header for proxied requests.

```json
{
  "_id": "user123",
  "username": "john.doe",
  "email": "john@example.com",
  "fullName": "John Doe",
  "firstName": "John",
  "lastName": "Doe",
  "birthDate": "1990-01-01",
  "roles": ["admin", "user"],
  "workspace": {
    "_id": "workspace456",
    "name": "Acme Corp",
    "roles": ["admin"],
    "labels": ["enterprise"]
  }
}
```

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

### Install Lightweight k3s Cluster

Source: https://docs.qelos.io/deployment/kubernetes-cluster-management

Installs k3s on a master node and provides instructions for joining worker nodes.

```bash
# On master node
curl -sfL https://get.k3s.io | sh -

# Get kubeconfig
sudo cat /var/lib/rancher/k3s/server/node-token

# On worker nodes
curl -sfL https://get.k3s.io | K3S_URL=https://<master-ip>:6443 K3S_TOKEN=<token> sh -
```

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

### Create New Resource Output

Source: https://docs.qelos.io/cli/push

Example console output when a new resource is created.

```text
Pushing component: new-component
Component pushed: new-component
```

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

### Public Plans Response Example

Source: https://docs.qelos.io/payments/plans

Example JSON response containing a list of active plans with public-safe fields.

```json
[
  {
    "_id": "plan-1",
    "name": "Starter",
    "description": "For individuals getting started",
    "features": ["5 projects", "1GB storage", "Email support"],
    "monthlyPrice": 9,
    "yearlyPrice": 90,
    "currency": "USD",
    "sortOrder": 0,
    "limits": { "maxProjects": 5, "storageGB": 1 }
  }
]
```

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

### Initialize Main Plugin File

Source: https://docs.qelos.io/plugin-play/installation

Basic configuration and server startup code for src/index.ts.

```typescript
import { start, configure } from '@qelos/plugin-play';

// Configure the plugin
configure({
  name: 'My Plugin',
  version: '1.0.0',
  description: 'My first Qelos plugin',
  manifestUrl: '/manifest.json',
  proxyPath: '/api/proxy'
}, {
  qelosUrl: process.env.QELOS_URL,
  qelosUsername: process.env.QELOS_USERNAME,
  qelosPassword: process.env.QELOS_PASSWORD,
  port: 3000
});

// Start the server
start().then(() => {
  console.log('Plugin is running!');
});
```

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

### Initialize a Plugin

Source: https://docs.qelos.io/plugin-play

Configure the plugin, define endpoints, register hooks, and start the server.

```typescript
import { start, configure, addEndpoint, registerToHook } from '@qelos/plugin-play';

// Configure your plugin
configure({
  name: 'My Plugin',
  version: '1.0.0',
  description: 'A sample plugin',
  manifestUrl: '/manifest.json',
  proxyPath: '/api/proxy'
}, {
  qelosUrl: process.env.QELOS_URL,
  qelosUsername: process.env.QELOS_USERNAME,
  qelosPassword: process.env.QELOS_PASSWORD
});

// Add an endpoint
addEndpoint('/api/hello', {
  method: 'GET',
  handler: async (request, reply) => {
    return { message: 'Hello from my plugin!' };
  }
});

// Subscribe to events
registerToHook({
  eventName: 'user.created'
}, async (request, reply) => {
  const { user } = request.body;
  console.log('New user created:', user);
  return { received: true };
});

// Start the server
start();
```

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

### Complete User Management Workflow

Source: https://docs.qelos.io/sdk/managing_users

A full example demonstrating initialization, authentication, and common user management operations.

```typescript
import QelosAdminSDK from '@qelos/sdk/administrator';

// Initialize the admin SDK
const sdkAdmin = new QelosAdminSDK({
  appUrl: 'https://your-qelos-app.com',
  fetch: globalThis.fetch
});

// Authenticate as admin
await sdkAdmin.authentication.oAuthSignin({
  username: 'admin@example.com',
  password: 'password'
});

// Get all users
const users = await sdkAdmin.users.getList();
console.log(`Found ${users.length} users`);

// Get users with specific role
const editors = await sdkAdmin.users.getList({ roles: ['editor'] });
console.log(`Found ${editors.length} editors`);

// Create a new user
const newUser = await sdkAdmin.users.create({
  username: 'johndoe',
  email: 'john@example.com',
  password: 'securePassword123',
  firstName: 'John',
  lastName: 'Doe',
  roles: ['user']
});

console.log(`Created user with ID: ${newUser._id}`);

// Update the user
const updatedUser = await sdkAdmin.users.update(newUser._id, {
  roles: ['user', 'editor'],
  metadata: {
    department: 'Engineering'
  }
});

// Get specific user
const user = await sdkAdmin.users.getUser(newUser._id);
console.log(`User: ${user.username} (${user.email})`);

// Store encrypted data
await sdkAdmin.users.setEncryptedData(newUser._id, 'api-keys', {
  githubToken: 'ghp_xxx',
  slackToken: 'xoxb-xxx'
});

// Retrieve encrypted data
const encryptedData = await sdkAdmin.users.getEncryptedData(newUser._id, 'api-keys');
console.log('Retrieved encrypted data');

// Remove the user
await sdkAdmin.users.remove(newUser._id);
console.log('User removed');
```

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

### Custom Event Integration Example

Source: https://docs.qelos.io/plugin-play/events

A combined example demonstrating both subscribing to an external event and dispatching a new custom event.

```typescript
import { registerToHook, getSdk } from '@qelos/plugin-play';

// Subscribe to custom events from another plugin
registerToHook({
  source: 'plugin:order-service',
  kind: 'order',
  eventName: 'order-completed'
}, async (request, reply) => {
  const { order } = request.body;
  
  // Process the completed order
  await sendInvoice(order);
  
  // Dispatch our own event
  await getSdk().events.dispatch({
    source: 'invoice-service',
    kind: 'invoice',
    eventName: 'invoice-sent',
    metadata: {
      orderId: order._id,
      invoiceId: 'INV-123'
    }
  });
  
  return { received: true };
});
```

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

### View General Help

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

Display the main help menu for the CLI tools.

```bash
qelos --help
qplay --help
```

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

### Generate blueprints without SDK guides

Source: https://docs.qelos.io/cli/blueprints

Run the generation command while disabling the automatic creation of Markdown SDK guides.

```bash
qelos blueprints generate ./blueprints \
  --uri mongodb://localhost:27017/legacy_app \
  --guides false
```

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

### GET /api/coupons

Source: https://docs.qelos.io/api/payments

List coupons. Admin only.

```APIDOC
## GET /api/coupons

### Description
List coupons. Admin only.

### Method
GET

### Endpoint
/api/coupons

### Parameters
#### Query Parameters
- **isActive** (boolean) - Optional - Filter by active status
```

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

### Retrieve all plugins

Source: https://docs.qelos.io/sdk/managing_plugins

Fetches a list of all installed plugins.

```typescript
const plugins = await sdkAdmin.managePlugins.getList();
```

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

### Initialize SDK in Vue 3

Source: https://docs.qelos.io/web-sdk/installation

Usage within a Vue component using the script setup syntax.

```vue
<!-- App.vue -->
<template>
  <div v-if="loading">Loading...</div>
  <div v-else>
    <h1>Welcome, {{ userData?.user?.fullName }}!</h1>
    <p>Session Code: {{ sessionCode }}</p>
  </div>
</template>

<script setup>
import { ref, onMounted } from 'vue';
import { authorize, code } from '@qelos/web-sdk';

const userData = ref(null);
const loading = ref(true);
const sessionCode = ref(code);

onMounted(async () => {
  try {
    userData.value = await authorize();
  } catch (err) {
    console.error('Authorization failed:', err);
  } finally {
    loading.value = false;
  }
});
</script>
```

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

### Disabling Minimap

Source: https://docs.qelos.io/pre-designed-frontends/components/monaco

Example of hiding the minimap feature.

```html
<monaco v-model="code" :minimap="false"></monaco>
```

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

### Build the project

Source: https://docs.qelos.io/getting-started/installation

Compiles the source code for the application.

```bash
pnpm build
```

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

### View push command help

Source: https://docs.qelos.io/cli/push

Display the help menu for the push command to see all available options.

```bash
qelos push --help
```

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

### GET /api/invoices/:invoiceId

Source: https://docs.qelos.io/api/payments

Returns a single invoice.

```APIDOC
## GET /api/invoices/:invoiceId

### Description
Returns a single invoice.

### Method
GET

### Endpoint
/api/invoices/:invoiceId

### Parameters
#### Path Parameters
- **invoiceId** (string) - Required
```

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

### Initialize Qelos SDK

Source: https://docs.qelos.io/sdk/core_functionality

Configure the SDK instance with the required application URL and fetch implementation.

```typescript
import QelosSDK from '@qelos/sdk';

const sdk = new QelosSDK({
  appUrl: 'https://your-qelos-app.com',
  fetch: globalThis.fetch, // Required: provide fetch implementation
  forceRefresh: true, // Enable automatic token refresh
  // Optional: provide initial tokens if available
  accessToken: 'existing-access-token',
  refreshToken: 'existing-refresh-token',
});
```

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

### GET /api/configurations/app-configuration

Source: https://docs.qelos.io/api/configurations

Retrieve the current application configuration.

```APIDOC
## GET /api/configurations/app-configuration

### Description
Retrieve the current application configuration.

### Method
GET

### Endpoint
/api/configurations/app-configuration

### Response
#### Success Response (200)
- **metadata** (object) - The current application configuration object.

#### Response Example
{
  "metadata": {
    "theme": "dark",
    "logo": "https://example.com/logo.png",
    "features": {
      "enableComments": true,
      "enableSharing": false
    }
  }
}
```

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

### Language Configuration

Source: https://docs.qelos.io/pre-designed-frontends/components/monaco

Example of setting the editor language to HTML.

```html
<monaco v-model="htmlCode" language="html"></monaco>
```

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

### Basic Usage Example

Source: https://docs.qelos.io/pre-designed-frontends/components/save-button

Minimal implementation of the save button.

```html
<save-button @click="saveForm"></save-button>
```

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

### Initialize backend SDK for regular users

Source: https://docs.qelos.io/sdk/basic_usage

Configures the standard SDK instance with an application URL and fetch implementation.

```typescript
// Import the regular version of the Qelos SDK
import QelosSDK from '@qelos/sdk';

// Create an instance of QelosSDK
const sdk = new QelosSDK({
  appUrl: 'https://yourdomain.com', // Change to 'http://localhost:3000' if running locally
  fetch: globalThis.fetch // Use globalThis.fetch in Node.js 18+ or window.fetch in browser
});

export default sdk;

// Example of fetching blocks
async function fetchBlocks() {
  try {
    const blocks = await sdk.blocks.getList();
    console.log(blocks);
  } catch (error) {
    console.error('Error fetching blocks:', error);
  }
}

fetchBlocks();
```

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

### Configuration Patterns

Source: https://docs.qelos.io/getting-started/quick-reference

Example of a feature flag configuration object.

```typescript
// config/features.ts
export const features = {
  userAuth: true,
  billing: {
    enabled: true,
    provider: 'stripe'
  },
  auditLog: true
}
```

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

### Get List of All Blueprints

Source: https://docs.qelos.io/sdk/blueprints_operations

Retrieves an array of all available blueprints.

```typescript
const blueprints = await sdk.blueprints.getList();
```

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

### Get Workspace Members

Source: https://docs.qelos.io/api/gateway-endpoint-reference

List all members associated with a workspace.

```typescript
await sdk.workspaces.getMembers('WORKSPACE_ID');
```
Tokens:
Raw