Fyso

https://docs.fyso.dev/docs/
Admin
Fyso is an agent-first platform for building business applications with entities, business rules,...
Tokens:118,094
Snippets:882
Trust Score:2.3
Update:7 months ago
Show doc for...
Tokens:
Raw
### Create Users and Manage Permissions

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Handles user creation within a tenant and defines entity-level access control using fyso_auth.

```javascript
fyso_auth({ action: "create_user", tenantSlug: "my-app", email: "dev@team.com", password: "securepass123", name: "Dev User", role: "member", permissions: { entities: { "tasks": ["create", "read", "update"] } } });
```

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

### Tenant Management

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Endpoints for listing and selecting the active workspace tenant.

```APIDOC
## POST /list_tenants

### Description
Retrieves a list of all available tenants for the authenticated user.

### Method
POST

### Endpoint
/list_tenants

## POST /select_tenant

### Description
Sets the active tenant context for subsequent operations.

### Method
POST

### Endpoint
/select_tenant

### Request Body
- **tenantSlug** (string) - Required - The unique identifier slug of the tenant.
```

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

### Deploy and Manage Static Sites

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Facilitates the deployment of static assets to Fyso subdomains and provides utilities for CI/CD integration.

```javascript
fyso_deploy({ action: "deploy", subdomain: "my-app", path: "/path/to/dist" });

fyso_deploy({ action: "list" });

fyso_deploy({ action: "generate_token", subdomain: "my-app" });
```

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

### Manage Business Rules

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Explains the lifecycle of business rules using fyso_rules, including generation from natural language, publishing, and testing.

```javascript
fyso_rules({ action: "generate", entityName: "tasks", description: "When a task is created, if no priority is set, default it to 'medium'" });

fyso_rules({ action: "publish", entityName: "tasks", ruleId: "rule-uuid" });

fyso_rules({ action: "test", entityName: "tasks", ruleId: "rule-uuid", testData: { "title": "New task without priority", "status": "open" } });
```

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

### MCP: Select Tenant Context

Source: https://docs.fyso.dev/docs/agents/mcp-vs-rest

Sets the tenant context for subsequent MCP tool calls. This is a one-time setup after initial authentication.

```javascript
select_tenant("my-company-abc123")
```

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

### Query Data with Pagination, Sorting, and Semantic Search

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Demonstrates how to retrieve records from the Fyso platform using the fyso_data function. Supports pagination, sorting, semantic search, and combined filtering.

```javascript
fyso_data({ action: "query", entity: "tasks", limit: 10, offset: 0 });

fyso_data({ action: "query", entity: "tasks", sort: "priority", order_dir: "desc" });

fyso_data({ action: "query", entity: "tasks", semantic: "authentication issues", min_similarity: 0.6, limit: 5 });

fyso_data({ action: "query", entity: "tasks", semantic: "UI improvements", filters: "status = open", limit: 10 });
```

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

### Fyso MCP: Select Tenant

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Lists available tenants and selects a specific tenant for the current workspace. This is the initial step before performing other operations.

```mcp
list_tenants()
select_tenant({ tenantSlug: "mi-empresa" })
```

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

### Install Claude Code Plugin via GitHub

Source: https://docs.fyso.dev/docs/getting-started/claude-plugin

Instructions for manually installing the Claude Code plugin by cloning the GitHub repository. This method requires navigating into the cloned directory and following the README.md instructions.

```bash
git clone https://github.com/fyso-dev/claude-plugin
cd claude-plugin
# Follow instructions in README.md
```

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

### Manage Schema with fyso_schema (JavaScript)

Source: https://docs.fyso.dev/docs/api/mcp-tools

Provides examples for managing entities, fields, and schema versions using the `fyso_schema` tool. This covers listing entities, getting schemas, adding/managing fields, generating new entities, and publishing or discarding drafts.

```javascript
// List all entities
fyso_schema({ action: "list" });

// Get the schema for a specific entity
fyso_schema({ action: "get", entityName: "users", version: "published" });

// Add a new field to an entity
fyso_schema({
  action: "add_field",
  entityName: "tasks",
  field: {
    name: "Priority",
    fieldKey: "priority",
    fieldType: "select",
    config: { options: ["Low", "Medium", "High"] }
  }
});

// Manage custom fields for an entity
fyso_schema({
  action: "manage_fields",
  entityName: "tasks",
  field_action: "list",
  field_type: "custom"
});

// Generate a new entity from a definition
fyso_schema({
  action: "generate",
  definition: {
    entity: { name: "Projects", displayName: "Projects" },
    fields: [
      { name: "Name", fieldKey: "name", fieldType: "text" },
      { name: "Description", fieldKey: "description", fieldType: "textarea" }
    ]
  },
  auto_publish: true,
  version_message: "Initial project entity"
});

// Publish an entity draft
fyso_schema({ action: "publish", entityName: "tasks", version_message: "Add priority field" });

// Discard an entity draft
fyso_schema({ action: "discard", entityName: "tasks" });

// Delete an entity
fyso_schema({ action: "delete", entityName: "old_entity", confirm: true });

// List pending schema changes
fyso_schema({ action: "list_changes" });
```

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

### Manage Fyso Tenants

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Interact with Fyso tenants using the `fyso_auth` function. This includes listing available tenants and selecting a specific tenant for subsequent operations. The tenant slug is used for selection.

```javascript
fyso_auth({ action: "list_tenants" })

fyso_auth({ action: "select_tenant", tenantSlug: "my-app" })
```

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

### Install Fyso Claude Plugin

Source: https://docs.fyso.dev/docs/getting-started/mcp-setup

Installs skills, hooks, and the MCP connection for Claude using the `@fyso/claude-plugin` package. Authentication is handled via OAuth, eliminating the need for API keys.

```bash
bunx @fyso/claude-plugin install
```

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

### Generate Deploy Token for CI/CD

Source: https://docs.fyso.dev/docs/agents/building-a-site

Generates a deploy token required for automated deployments. This token should be used within your GitHub Actions workflow for seamless integration. Refer to the GitHub Actions Deployment guide for comprehensive setup instructions.

```javascript
generate_deploy_token({ subdomain: "support-app" })
```

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

### Get Available Slots - Single Day Example

Source: https://docs.fyso.dev/docs/scheduling/availability

Demonstrates how to use the `get_available_slots` MCP tool to find available time slots for a specific professional on a single given date. Requires the professional's UUID and the target date.

```javascript
get_available_slots({
  profesional_id: "uuid-del-profesional",
  fecha: "2026-02-20"
})
```

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

### Execute Tool

Source: https://docs.fyso.dev/docs/agents/channel-tools

Consumers call tools through the channel execution endpoint. This example shows how to execute a 'search-products' tool.

```APIDOC
## POST /api/channels/{channel_slug}/tools/{tool_slug}/execute

### Description
Executes a specified tool within a given channel.

### Method
POST

### Endpoint
`/api/channels/product-catalog/tools/search-products/execute`

### Parameters
#### Path Parameters
- **channel_slug** (string) - Required - The slug of the channel containing the tool.
- **tool_slug** (string) - Required - The slug of the tool to execute.

#### Query Parameters
None

#### Request Body
- **query** (string) - Required - The query parameter for the tool (e.g., search term).

### Request Example
```json
{
  "query": "wireless"
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the execution was successful.
- **data** (object) - The result data from the tool execution.
  - **records** (array) - List of records returned by the tool.
    - **id** (string) - Unique identifier for the record.
    - **name** (string) - Name of the item.
    - **price** (number) - Price of the item in cents.
    - **category** (string) - Category of the item.
  - **total** (number) - Total number of records found.
- **meta** (object) - Metadata about the execution.
  - **executionTimeMs** (number) - The time taken for execution in milliseconds.

#### Response Example (Search)
```json
{
  "success": true,
  "data": {
    "records": [
      {
        "id": "rec-uuid",
        "name": "Wireless Mouse",
        "price": 2999,
        "category": "peripherals"
      }
    ],
    "total": 1
  },
  "meta": {
    "executionTimeMs": 42
  }
}
```

#### Response Example (Create)
```json
{
  "success": true,
  "data": {
    "id": "new-record-uuid",
    "data": {
      "order_id": "generated-uuid",
      "customer_name": "Acme Corp",
      "status": "pending"
    }
  },
  "meta": {
    "executionTimeMs": 38
  }
}
```
```

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

### Install n8n-nodes-fyso via npm

Source: https://docs.fyso.dev/docs/integrations/n8n

Instructions for installing the Fyso community node in a self-hosted n8n environment using the npm package manager.

```bash
cd ~/.n8n
npm install n8n-nodes-fyso
```

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

### Install Fyso MCP Server via Smithery

Source: https://docs.fyso.dev/docs/getting-started/mcp-setup

Installs the `@fyso/mcp-server` package directly from Smithery.ai, specifying the client as 'claude'. This provides an alternative method for setting up the MCP server.

```bash
npx @smithery/cli install @fyso/mcp-server --client claude
```

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

### Compute Business Rule Example

Source: https://docs.fyso.dev/docs/business-rules/overview

A 'compute' rule type automatically calculates fields when other specified fields change. This example shows how to compute a 'total' based on 'cantidad' and 'precio'.

```json
{
  "type": "compute",
  "triggers": ["cantidad", "precio"],
  "compute": {
    "total": "cantidad * precio"
  }
}
```

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

### GET /list_static_sites

Source: https://docs.fyso.dev/docs/deployment/static-sites

Retrieves a list of all active static site deployments associated with the account.

```APIDOC
## GET list_static_sites

### Description
Lists all active deployments, returning details such as subdomain, URL, size, and deployment date.

### Method
GET

### Response
#### Success Response (200)
- **sites** (array) - List of active deployment objects.
```

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

### File Field Configuration Example

Source: https://docs.fyso.dev/docs/entities/field-types

Provides an example configuration for the 'file' field type in Fyso. This includes settings for allowed MIME types, maximum file size, and whether multiple files are permitted.

```json
{
  "accept": ["image/*", "application/pdf"],
  "maxSize": 5242880,
  "multiple": false
}
```

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

### On Query Business Rule Example

Source: https://docs.fyso.dev/docs/business-rules/overview

An 'on_query' rule type filters records at query time by compiling DSL conditions into SQL WHERE clauses. This is used for row-level security, ensuring only records matching the condition are returned. This example filters records based on the creator and status.

```json
{
  "type": "on_query",
  "triggerType": "on_query",
  "conditions": "createdBy == $userId AND status != 'deleted'"
}
```

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

### GET /api/invitations

Source: https://docs.fyso.dev/docs/admin/users

Retrieves a list of all invitations for the tenant, ordered by creation date.

```APIDOC
## GET /api/invitations

### Description
Returns all invitations for the tenant. Expired pending invitations are automatically updated to 'expired' status.

### Method
GET

### Endpoint
https://api.fyso.dev/api/invitations

### Response
#### Success Response (200)
- **success** (boolean) - Indicates success
- **data** (array) - List of invitation objects

#### Response Example
{
  "success": true,
  "data": [
    {
      "id": "uuid",
      "token": "a3f1b2c4...hex64",
      "status": "pending",
      "email": "colleague@example.com"
    }
  ]
}
```

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

### Fyso MCP: Add Business Rule

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Adds a business rule to an entity, such as validation. This example demonstrates a rule to ensure the email field is required, with a custom error message.

```mcp
generate_business_rule({
  entityName: "clientes",
  dsl: {
    type: "validate",
    triggers: ["email"],
    validate: [{
      id: "email_requerido",
      condition: "len(email) > 0",
      message: "El email es obligatorio",
      severity: "error"
    }]
  },
  auto_publish: true
})
```

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

### Query Fyso Records

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Retrieve records from an entity using the `fyso_data` function with the `query` action. Supports filtering, pagination, sorting, and semantic search. Examples show simple and compound filters.

```javascript
fyso_data({
  action: "query",
  entity: "tasks",
  filters: "status = open"
})

fyso_data({
  action: "query",
  entity: "tasks",
  filters: "status = open AND priority = high"
})
```

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

### Fyso SDK Quick Start Commands

Source: https://docs.fyso.dev/docs/agents/overview

Basic SDK commands for selecting a tenant, listing schema definitions, and querying data. These functions facilitate interaction with the Fyso platform backend.

```javascript
fyso_auth({ action: "select_tenant", tenantSlug: "my-workspace" });
fyso_schema({ action: "list" });
fyso_data({ action: "query", entity: "contacts", limit: 5 });
```

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

### Get Available Slots - Date Range Example

Source: https://docs.fyso.dev/docs/scheduling/availability

Illustrates how to use the `get_available_slots` MCP tool to retrieve available time slots for a professional within a specified date range. Requires the professional's UUID and the start and end dates of the range (max 90 days).

```javascript
get_available_slots({
  profesional_id: "uuid-del-profesional",
  desde: "2026-02-20",
  hasta: "2026-02-28"
})
```

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

### Initialize Tenant and Entities

Source: https://docs.fyso.dev/docs/agents/building-a-site

Sets up the application environment by selecting a tenant and generating the 'agents' and 'tickets' data structures. These entities form the foundation of the support system.

```JavaScript
select_tenant({ tenantSlug: "support-app" });

generate_entity({
  name: "agents",
  fields: [
    { "name": "name", "type": "text", "required": true },
    { "name": "email", "type": "text", "required": true },
    { "name": "department", "type": "select", "options": ["billing", "technical", "general"] }
  ]
});

publish_entity({ entityName: "agents", message: "Initial agents entity" });

generate_entity({
  name: "tickets",
  fields: [
    { "name": "title", "type": "text", "required": true },
    { "name": "description", "type": "long_text" },
    { "name": "status", "type": "select", "options": ["open", "in_progress", "resolved"] },
    { "name": "priority", "type": "select", "options": ["low", "medium", "high", "critical"] },
    { "name": "customer_email", "type": "text", "required": true },
    { "name": "assigned_to", "type": "relation", "relatedEntity": "agents" }
  ]
});

publish_entity({ entityName: "tickets", message: "Initial tickets entity with agent relation" });
```

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

### Record Operations

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Endpoints for creating and querying data records within an entity.

```APIDOC
## POST /create_record

### Description
Inserts a new record into a specified entity.

### Method
POST

### Endpoint
/create_record

### Request Body
- **entityName** (string) - Required - The name of the target entity.
- **data** (object) - Required - Key-value pairs representing the record fields.

## POST /query_records

### Description
Retrieves records from an entity based on filter criteria.

### Method
POST

### Endpoint
/query_records

### Request Body
- **entityName** (string) - Required - The name of the target entity.
- **filter** (string) - Optional - Query filter string.
- **limit** (integer) - Optional - Maximum number of records to return.
```

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

### Typical Fyso Workflow Example

Source: https://docs.fyso.dev/docs/getting-started/mcp-setup

Demonstrates a typical sequence of operations within the Fyso workspace, including listing tenants, selecting a tenant, listing entities, and querying records with a specified limit.

```text
list_tenants()
→ select_tenant({ tenantSlug: "mi-empresa" })
→ list_entities()
→ query_records({ entityName: "clientes", limit: 10 })
```

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

### Business Rules

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Endpoints for generating and applying validation or business logic rules to entities.

```APIDOC
## POST /generate_business_rule

### Description
Defines a business rule (e.g., validation) for an entity.

### Method
POST

### Endpoint
/generate_business_rule

### Request Body
- **entityName** (string) - Required - The target entity.
- **dsl** (object) - Required - The domain-specific language object defining the rule logic.
- **auto_publish** (boolean) - Optional - Whether to publish the rule immediately.
```

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

### Example: Profile Avatar Upload and Display

Source: https://docs.fyso.dev/docs/admin/files

Demonstrates a complete workflow for uploading a profile avatar using the REST API and then displaying it via its public URL. The upload response includes the file key, which is then used in the download URL.

```bash
# Upload an avatar
curl -X POST https://api.fyso.dev/api/files/contacts/rec_123/avatar \
  -H "Authorization: Bearer <token>" \
  -F "file=@photo.jpg"

# Response includes the file key
# { "success": true, "data": { "key": "my-app/contacts/rec_123/avatar/a1b2c3.jpg", ... } }

# Display the avatar (public URL, no auth needed)
curl https://api.fyso.dev/api/files/my-app/contacts/rec_123/avatar/a1b2c3.jpg
```

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

### Entity Management

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Endpoints for defining and generating data structures (entities) within the application.

```APIDOC
## POST /generate_entity

### Description
Creates a new entity (data table) with specified fields.

### Method
POST

### Endpoint
/generate_entity

### Request Body
- **definition** (object) - Required - The schema definition including entity name and fields.
- **auto_publish** (boolean) - Optional - Whether to publish the entity immediately.
- **version_message** (string) - Optional - Commit message for the entity creation.
```

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

### GET /api/entities/{entity}/records

Source: https://docs.fyso.dev/docs/agents/mcp-vs-rest

Retrieves a paginated list of records for a specific entity.

```APIDOC
## GET /api/entities/{entity}/records

### Description
Retrieves a list of records for the specified entity, including pagination metadata.

### Method
GET

### Endpoint
https://api.fyso.dev/api/entities/{entity}/records

### Parameters
#### Path Parameters
- **entity** (string) - Required - The name of the entity to query.

#### Query Parameters
- **filter.{field}** (string) - Optional - Filter records by specific fields.
- **limit** (integer) - Optional - Number of records to return.

### Request Example
curl -H "Authorization: Bearer JWT_TOKEN" \
  -H "X-Tenant-ID: my-company-abc123" \
  "https://api.fyso.dev/api/entities/tickets/records?filter.status=open&limit=10"

### Response
#### Success Response (200)
- **data** (object) - Contains items array and pagination metadata.

#### Response Example
{
  "success": true,
  "data": {
    "items": [{"id": "uuid-1", "nombre": "Juan Perez"}],
    "total": 42,
    "page": 1,
    "limit": 20
  }
}
```

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

### Publish App using publish_app

Source: https://docs.fyso.dev/docs/admin/apps

Publishes a tenant as an installable app by exporting its metadata and registering it in the catalog. Requires 'name' and 'slug' parameters. 'description' and 'icon' are optional.

```javascript
publish_app({
  name: "Sistema de Turnos",
  slug: "sistema-turnos",
  description: "Gestion de turnos para profesionales de salud",
  icon: "calendar"
})
```

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

### POST /deploy_static_site

Source: https://docs.fyso.dev/docs/deployment/static-sites

Deploys a static site to a fyso.dev subdomain. Requires either a local path or a base64 encoded bundle.

```APIDOC
## POST deploy_static_site

### Description
Deploys a static site build directory to the Fyso platform. If the MCP server has filesystem access, it handles the upload; otherwise, it provides a command for manual execution.

### Method
POST

### Parameters
#### Request Body
- **subdomain** (string) - Required - The desired subdomain (e.g., "mi-portfolio").
- **path** (string) - Conditional - Absolute path to the build directory.
- **bundle_base64** (string) - Conditional - ZIP file in base64 format (only for sites < 5KB).

### Request Example
{
  "subdomain": "mi-portfolio",
  "path": "/home/user/my-site/dist"
}

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the deployment was successful.
- **data** (object) - Contains the deployed URL and subdomain.

#### Response Example
{
  "success": true,
  "message": "Site deployed successfully",
  "data": {
    "url": "https://mi-portfolio-sites.fyso.dev",
    "subdomain": "mi-portfolio"
  }
}
```

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

### Create Records

Source: https://docs.fyso.dev/docs/agents/building-a-site

Demonstrates how to populate the system with data by creating agent and ticket records. The ticket record includes a reference to an agent via a UUID.

```JavaScript
create_record({
  entityName: "agents",
  data: {
    "name": "Alice Chen",
    "email": "alice@support.com",
    "department": "technical"
  }
});

create_record({
  entityName: "tickets",
  data: {
    "title": "Cannot reset password",
    "description": "Customer clicks reset link but gets a 404 page",
    "status": "open",
    "priority": "high",
    "customer_email": "customer@example.com",
    "assigned_to": "agent-uuid-1"
  }
});
```

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

### Create User and Assign Role

Source: https://docs.fyso.dev/docs/agents/building-a-site

Creates a new user within a tenant and subsequently assigns a role to that user. Requires tenant slug, user credentials, name, and initial role for creation, followed by user ID and role name for assignment.

```javascript
create_user({
  tenantSlug: "support-app",
  email: "agent1@support.com",
  password: "securepass123",
  name: "Agent One",
  role: "member"
})

assign_role({
  userId: "user-uuid-1",
  roleName: "support_agent"
})
```

```javascript
create_user({
  tenantSlug: "support-app",
  email: "manager@support.com",
  password: "securepass456",
  name: "Manager User",
  role: "admin"
})

assign_role({
  userId: "user-uuid-2",
  roleName: "support_manager"
})
```

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

### Fyso MCP: Query Records

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Queries records from a specified entity based on a filter and a limit. This allows for retrieving specific data subsets from your entities.

```mcp
query_records({
  entityName: "clientes",
  filter: "nombre contains Juan",
  limit: 10
})
```

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

### Add and Verify Custom Domain

Source: https://docs.fyso.dev/docs/agents/building-a-site

Configures a custom domain for your site. First, add the domain by providing the subdomain and desired domain name. Then, follow the DNS instructions (CNAME record) provided in the response and verify the setup. Once verified, your site will be accessible via both the default fyso.dev subdomain and your custom domain with automatic SSL.

```javascript
set_custom_domain({
  subdomain: "support-app",
  action: "add",
  domain: "support.mycompany.com"
})
```

```javascript
set_custom_domain({
  subdomain: "support-app",
  action: "verify"
})
```

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

### Implement Dynamic Login and Data Fetching in HTML/JavaScript

Source: https://docs.fyso.dev/docs/agents/static-site-auth

Provides a complete HTML and JavaScript example for implementing dynamic login. Users enter credentials, a JWT is obtained via API call, and then used to fetch personalized data. This is ideal for authenticated experiences where users see personalized data.

```html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>My Fyso App</title>
</head>
<body>
  <div id="login-form">
    <h2>Login</h2>
    <input type="email" id="email" placeholder="Email" />
    <input type="password" id="password" placeholder="Password" />
    <button onclick="login()">Login</button>
  </div>

  <div id="app" style="display:none">
    <h2>Records</h2>
    <ul id="record-list"></ul>
  </div>

  <script>
    const TENANT_ID = 'my-company-abc123';
    const BASE_URL = 'https://api.fyso.dev/api';
    let token = null;

    async function login() {
      const email = document.getElementById('email').value;
      const password = document.getElementById('password').value;

      const res = await fetch(`${BASE_URL}/auth/tenant/login`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'X-Tenant-ID': TENANT_ID,
        },
        body: JSON.stringify({ email, password }),
      });

      const json = await res.json();
      if (json.success) {
        token = json.data.token;
        document.getElementById('login-form').style.display = 'none';
        document.getElementById('app').style.display = 'block';
        loadRecords();
      } else {
        alert('Login failed: ' + (json.error?.message || 'Unknown error'));
      }
    }

    async function loadRecords() {
      const res = await fetch(`${BASE_URL}/entities/products/records`, {
        headers: {
          'Authorization': `Bearer ${token}`,
          'X-Tenant-ID': TENANT_ID,
        },
      });

      const json = await res.json();
      const list = document.getElementById('record-list');
      list.innerHTML = '';

      for (const record of json.data.items) {
        const li = document.createElement('li');
        li.textContent = record.name || record.id;
        list.appendChild(li);
      }
    }
  </script>
</body>
</html>
```

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

### Fyso MCP: Create Record

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Creates a new record within a specified entity. It takes the entity name and a data object containing the field values for the new record.

```mcp
create_record({
  entityName: "clientes",
  data: {
    nombre: "Juan Perez",
    email: "juan@example.com",
    telefono: "+54 11 1234-5678"
  }
})
```

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

### Use Platform Key for API Access (cURL Example)

Source: https://docs.fyso.dev/docs/admin/api-management

Demonstrates how to include a platform key in the Authorization header to access API endpoints. The middleware enforces permissions based on the key's role and the requested operation.

```bash
curl -H "Authorization: Bearer fyso_pkey_abc123..." \
  https://api.fyso.dev/api/entities/contacts/records
```

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

### Publish Fyso Entity

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Publish a created entity to make it live using the `fyso_schema` function with the `publish` action. This requires the entity name and a version message to track changes.

```javascript
fyso_schema({
  action: "publish",
  entityName: "tasks",
  version_message: "Initial version"
})
```

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

### Deploy Static Site

Source: https://docs.fyso.dev/docs/agents/building-a-site

Deploys a static frontend application to a specified subdomain. Requires the desired subdomain and the path to the compiled frontend distribution files.

```javascript
deploy_static_site({
  subdomain: "support-app",
  path: "/path/to/your/frontend/dist"
})
```

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

### Query Records via REST API

Source: https://docs.fyso.dev/docs/agents/overview

Example of fetching records from a Fyso entity using a standard HTTP GET request. Requires an Authorization header with a valid API key.

```bash
curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.fyso.dev/api/entities/products/records?limit=10
```

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

### Create Flow for Welcome Email

Source: https://docs.fyso.dev/docs/admin/flows

An example of creating a flow that sends a welcome email to new users. It triggers when a record is created in the 'users' entity and uses the 'send_email' step with interpolated user data for personalization.

```javascript
create_flow({
  name: "welcome-email",
  triggerType: "record.created",
  triggerConfig: { entity: "users" },
  steps: [
    {
      type: "send_email",
      config: {
        to: "{{email}}",
        subject: "Welcome to the platform",
        body: "Hi {{name}}, thanks for signing up."
      }
    }
  ],
  isActive: true
})
```

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

### Fyso MCP: Create Entity

Source: https://docs.fyso.dev/docs/getting-started/quick-start

Generates a new entity (table) within Fyso, defining its name, display name, and fields with their respective types and requirements. The entity can be automatically published.

```mcp
generate_entity({
  definition: {
    entity: { name: "clientes", displayName: "Clientes" },
    fields: [
      { name: "Nombre", fieldKey: "nombre", fieldType: "text", isRequired: true },
      { name: "Email", fieldKey: "email", fieldType: "email" },
      { name: "Telefono", fieldKey: "telefono", fieldType: "phone" }
    ]
  },
  auto_publish: true,
  version_message: "Initial entity"
})
```

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

### Onboarding Conversation Tool

Source: https://docs.fyso.dev/docs/api/mcp-tools

Initiates an onboarding conversation to suggest entities and fields based on business type.

```APIDOC
## POST /fyso_welcome

### Description
Provides an onboarding conversation tool that suggests starter entities and fields based on the provided business type.

### Method
POST

### Endpoint
/fyso_welcome

### Parameters
#### Request Body
- **businessType** (string) - Required - Business category (e.g., `freelancer`, `clinic`, `ecommerce`, `saas`, `nonprofit`, `other`).

### Request Example
```json
{
  "businessType": "ecommerce"
}
```

### Response
#### Success Response (200)
- **suggestions** (object) - Suggested entities, fields, and next steps.

#### Response Example
```json
{
  "suggestions": {
    "entities": [...],
    "fields": [...],
    "next_steps": "..."
  }
}
```
```

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

### Create Fyso Records

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Add data records to an existing entity using the `fyso_data` function with the `create` action. This involves specifying the entity name and providing the data as a JSON object.

```javascript
fyso_data({
  action: "create",
  entity: "tasks",
  data: {
    "title": "Fix login bug",
    "description": "Users get 500 error on login with special characters in password",
    "status": "open",
    "priority": "high",
    "assignee": "alice@team.com"
  }
})
```

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

### Relation Field Configuration Example

Source: https://docs.fyso.dev/docs/entities/field-types

Illustrates the configuration for the 'relation' field type in Fyso. This field establishes a reference to a record in another entity, requiring the 'relatedEntity' name for proper setup.

```json
{
  "relatedEntity": "clientes"
}
```

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

### Execute Tool via REST API

Source: https://docs.fyso.dev/docs/agents/channel-tools

Demonstrates how to trigger a tool execution using a POST request with an authorization bearer token.

```bash
curl -X POST https://api.fyso.dev/api/channels/product-catalog/tools/search-products/execute \
  -H "Authorization: Bearer <consumer-token>" \
  -H "Content-Type: application/json" \
  -d '{"query": "wireless"}'
```

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

### Create Fyso Entity Schema

Source: https://docs.fyso.dev/docs/agents/mcp-quickstart

Define and create a new data entity within Fyso using the `fyso_schema` function with the `generate` action. This involves providing an entity name and a list of fields with their respective types and configurations.

```javascript
fyso_schema({
  action: "generate",
  definition: {
    entity: { name: "tasks" },
    fields: [
      { "name": "title", "fieldKey": "title", "fieldType": "text" },
      { "name": "description", "fieldKey": "description", "fieldType": "textarea" },
      { "name": "status", "fieldKey": "status", "fieldType": "select", "config": { "options": ["open", "in_progress", "done"] } },
      { "name": "priority", "fieldKey": "priority", "fieldType": "select", "config": { "options": ["low", "medium", "high", "critical"] } },
      { "name": "assignee", "fieldKey": "assignee", "fieldType": "text" }
    ]
  }
})
```

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

### POST /auth/invite/accept

Source: https://docs.fyso.dev/docs/api/rest-api

Accepts a tenant invitation and creates a new tenant user account using an invitation token.

```APIDOC
## POST /auth/invite/accept

### Description
Accepts a tenant invitation and creates a tenant user account. No prior authentication is needed as the invitation token acts as the gate.

### Method
POST

### Endpoint
/auth/invite/accept

### Parameters
#### Request Body
- **token** (string) - Required - The invitation token provided via email.
- **email** (string) - Required - The user's email address.
- **name** (string) - Required - The user's full name.
- **password** (string) - Required - The user's desired password.

### Request Example
{
  "token": "a1b2c3...",
  "email": "newuser@example.com",
  "name": "New User",
  "password": "securepass123"
}

### Response
#### Success Response (201)
- **success** (boolean) - Indicates if the operation was successful.
- **data** (object) - The created user object containing id, email, name, and role.

#### Response Example
{
  "success": true,
  "data": {
    "id": "uuid",
    "email": "newuser@example.com",
    "name": "New User",
    "role": "member"
  }
}
```

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

### POST /api/users

Source: https://docs.fyso.dev/docs/agents/building-a-site

Create a new user within a specific tenant and assign them a role.

```APIDOC
## POST /api/users

### Description
Creates a new user account for a specified tenant and assigns a role to manage permissions.

### Method
POST

### Endpoint
/api/users

### Request Body
- **tenantSlug** (string) - Required - The slug of the tenant.
- **email** (string) - Required - User email address.
- **password** (string) - Required - User password.
- **name** (string) - Required - Full name of the user.
- **role** (string) - Required - Initial role assignment.

### Request Example
{
  "tenantSlug": "support-app",
  "email": "agent1@support.com",
  "password": "securepass123",
  "name": "Agent One",
  "role": "member"
}
```

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

### Boolean Field Example Value

Source: https://docs.fyso.dev/docs/entities/field-types

An example value for the 'boolean' field type, representing a true/false state.

```boolean
true
```

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

### Automate Deployment with GitHub Actions

Source: https://docs.fyso.dev/docs/deployment/github-actions

A complete CI/CD workflow configuration for GitHub Actions. It handles environment setup, build execution, dynamic token generation, and file uploading to the Fyso platform.

```YAML
name: Deploy to Fyso Sites
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npm run build
      - name: Generate deploy token
        id: token
        env:
          FYSO_API_KEY: ${{ secrets.FYSO_API_KEY }}
          FYSO_API_URL: ${{ secrets.FYSO_API_URL }}
        run: |
          TOKEN=$(curl -s -X POST "$FYSO_API_URL/sites/mi-portfolio/deploy-token" \
            -H "Authorization: Bearer $FYSO_API_KEY" | jq -r '.token')
          echo "token=$TOKEN" >> $GITHUB_OUTPUT
      - name: Deploy to Fyso
        env:
          FYSO_API_URL: ${{ secrets.FYSO_API_URL }}
        run: |
          cd dist
          zip -qr /tmp/site.zip .
          curl -X POST "$FYSO_API_URL/sites/mi-portfolio/deploy" \
            -H "Authorization: Bearer ${{ steps.token.outputs.token }}" \
            -F "file=@/tmp/site.zip"
```

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

### Example Request using cURL

Source: https://docs.fyso.dev/docs/billing/storage-usage

This cURL command demonstrates how to call the storage usage API endpoint. It includes the necessary 'Authorization' header with a Bearer token and the target URL.

```Shell
curl -H "Authorization: Bearer <token>" \
  https://api.fyso.dev/api/usage/storage
```

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

### Relation Field Example Value

Source: https://docs.fyso.dev/docs/entities/field-types

An example value for the 'relation' field type, which is the UUID of a related record in another entity.

```text
"6bd2d1db-d104-4a15-977a-a759c38608a9"
```

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

### Publishing a Channel

Source: https://docs.fyso.dev/docs/agents/channel-tools

Create a new channel for a tenant to publish tools. A tenant can only have one channel.

```APIDOC
## POST /api/channels

### Description
Creates a new channel for a tenant. Each tenant can publish exactly one channel.

### Method
POST

### Endpoint
/api/channels

### Parameters
#### Headers
- **Authorization** (string) - Required - Bearer token for authentication.
- **Content-Type** (string) - Required - application/json

#### Request Body
- **name** (string) - Required - The name of the channel.
- **description** (string) - Optional - A description of the channel.
- **tags** (array of strings) - Optional - Tags associated with the channel.

### Request Example
```json
{
  "name": "Product Catalog",
  "description": "Search and browse our product inventory",
  "tags": ["ecommerce", "products"]
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **data** (object) - Contains the details of the created channel.
  - **id** (string) - The unique identifier of the channel.
  - **tenant_id** (string) - The identifier of the tenant who owns the channel.
  - **name** (string) - The name of the channel.
  - **slug** (string) - A URL-friendly version of the channel name.
  - **description** (string) - The description of the channel.
  - **tags** (array of strings) - Tags associated with the channel.
  - **is_active** (boolean) - Indicates if the channel is active.
  - **created_at** (string) - The timestamp when the channel was created.
  - **updated_at** (string) - The timestamp when the channel was last updated.

#### Response Example
```json
{
  "success": true,
  "data": {
    "id": "uuid",
    "tenant_id": "uuid",
    "name": "Product Catalog",
    "slug": "product-catalog",
    "description": "Search and browse our product inventory",
    "tags": ["ecommerce", "products"],
    "is_active": true,
    "created_at": "2026-03-01T10:00:00Z",
    "updated_at": "2026-03-01T10:00:00Z"
  }
}
```
```

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

### Select Field Example Value

Source: https://docs.fyso.dev/docs/entities/field-types

An example value for the 'select' field type, showing a selected option from a predefined list.

```text
"activo"
```

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

### Deploy Static Site (Local Mode)

Source: https://docs.fyso.dev/docs/deployment/static-sites

Deploys a static site when the MCP server has filesystem access. It automatically compresses the specified directory and uploads it. Requires 'subdomain' and 'path' parameters.

```javascript
deploy_static_site({
  subdomain: "mi-portfolio",
  path: "/home/user/my-site/dist"
})
```

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

### Phone Field Example Value

Source: https://docs.fyso.dev/docs/entities/field-types

An example value for the 'phone' field type, showing a typical phone number format.

```text
"+54 11 1234-5678"
```

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

### POST /api/platform/invitations/:token/accept

Source: https://docs.fyso.dev/docs/admin/platform-invitations

Allows a user to accept an invitation and register their new account.

```APIDOC
## POST /api/platform/invitations/:token/accept

### Description
Registers a new user using a valid invitation token. The user is logged in immediately upon success.

### Method
POST

### Endpoint
/api/platform/invitations/:token/accept

### Parameters
#### Path Parameters
- **token** (string) - Required - The invitation token.

#### Request Body
- **name** (string) - Required - Full name (min 2 chars).
- **password** (string) - Required - Password (min 8 chars).

### Request Example
{
  "name": "New User",
  "password": "securepassword"
}

### Response
#### Success Response (200)
- **token** (string) - The session token for the newly created account.

#### Response Example
{
  "success": true,
  "data": {
    "token": "<session-token>"
  }
}
```

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

### Email Field Example Value

Source: https://docs.fyso.dev/docs/entities/field-types

An example value for the 'email' field type, demonstrating a standard email address format.

```text
"juan@example.com"
```

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

### Create User with MCP Tool

Source: https://docs.fyso.dev/docs/admin/users

Creates a new user within a specific tenant. Requires tenant slug, email, password, and name. Optional parameters include role, permissions, and metadata. The password must be at least 8 characters long and will be hashed.

```javascript
create_user({
  tenantSlug: "mi-empresa",
  email: "vendedor@empresa.com",
  password: "password123",
  name: "Carlos Vendedor",
  role: "member",
  permissions: {
    entities: {
      clientes: ["create", "read", "update"],
      productos: ["read"]
    }
  }
})
```

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

### Number Field Example Value

Source: https://docs.fyso.dev/docs/entities/field-types

An example value for the 'number' field type, representing a numeric value which can be an integer or a decimal.

```number
150.50
```

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

### Text Field Example Value

Source: https://docs.fyso.dev/docs/entities/field-types

An example of a value for the 'text' field type, which stores short, single-line text strings.

```text
"Juan Perez"
```

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

### POST /set_custom_domain

Source: https://docs.fyso.dev/docs/deployment/static-sites

Configures custom domain settings for a deployed site (Pro plan required).

```APIDOC
## POST set_custom_domain

### Description
Manages custom domains for a site, including adding, verifying, checking status, or removing a domain.

### Method
POST

### Parameters
#### Request Body
- **subdomain** (string) - Required - The subdomain of the deployed site.
- **action** (string) - Required - One of: "add", "verify", "status", or "remove".
- **domain** (string) - Conditional - The custom domain to add (e.g., "app.mycompany.com").

### Request Example
{
  "subdomain": "mi-portfolio",
  "action": "add",
  "domain": "app.mycompany.com"
}
```
Tokens:
Raw