brainkb

Authenticate to BrainKB with the user's credentials and cache the JWT for THIS session only (isolated per caller). The password/token are never echoed. Uses single sign-on: one login mints a refresh token, cached for THIS session, which is exchanged on demand for per-service access tokens (query_service, usermanagement, …). Falls back to a legacy per-service token if the backend has no SSO. On the hosted multi-user remote you can skip this and instead have your client send an 'Authorization: Bearer <token>' header (a refresh token unlocks all services).

{
  "type": "object",
  "properties": {
    "email": {
      "title": "Email",
      "type": "string"
    },
    "password": {
      "title": "Password",
      "type": "string"
    },
    "base_url": {
      "default": "",
      "title": "Base Url",
      "type": "string"
    }
  },
  "required": [
    "email",
    "password"
  ],
  "title": "brainkb_loginArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "brainkb_loginOutput"
}

Start an OAuth login (Globus / ORCID / GitHub) for THIS session — use this instead of brainkb_login when the user signs in with Globus rather than a password. Returns a URL to open in a browser; after signing in, the page shows a short one-time code — pass it to brainkb_finish_login(code) to complete. (The browser step is unavoidable: only the user can consent at the provider.)

{
  "type": "object",
  "properties": {
    "provider": {
      "default": "globus",
      "title": "Provider",
      "type": "string"
    },
    "base_url": {
      "default": "",
      "title": "Base Url",
      "type": "string"
    }
  },
  "title": "brainkb_globus_loginArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "brainkb_globus_loginOutput"
}

Complete an OAuth login started with brainkb_globus_login by exchanging the one-time code shown in the browser for a session token. The code is single-use and never echoed back.

{
  "type": "object",
  "properties": {
    "code": {
      "title": "Code",
      "type": "string"
    },
    "base_url": {
      "default": "",
      "title": "Base Url",
      "type": "string"
    }
  },
  "required": [
    "code"
  ],
  "title": "brainkb_finish_loginArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "brainkb_finish_loginOutput"
}

Forget the cached token for this session.

{
  "type": "object",
  "properties": {},
  "title": "brainkb_logoutArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "brainkb_logoutOutput"
}

Report the current caller's auth state (email, authenticated, and when the cached session expires). When signed in it also returns base_url — the backend THIS SERVER talks to, which on a hosted deployment is an internal address and says nothing about the caller's own machine.

{
  "type": "object",
  "properties": {},
  "title": "brainkb_whoamiArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "additionalProperties": true,
      "title": "Result",
      "type": "object"
    }
  },
  "required": [
    "result"
  ],
  "title": "brainkb_whoamiOutput"
}

Generate a Personal Access Token (PAT) for browser-free auth. Requires you to be logged in already (brainkb_login or brainkb_globus_login). The token is shown ONCE and never again — copy it and set it as BRAINKB_TOKEN in your MCP/skill config; then no login or browser is needed until it expires. `name`: a label so you can tell tokens apart (e.g. 'laptop'). `days`: lifetime (default 90, server-capped). Treat the returned token like a password.

{
  "type": "object",
  "properties": {
    "name": {
      "default": "",
      "title": "Name",
      "type": "string"
    },
    "days": {
      "default": 90,
      "title": "Days",
      "type": "integer"
    }
  },
  "title": "brainkb_create_tokenArguments"
}

List your Personal Access Tokens (metadata only — the secret is never shown): id, name, prefix, created/last-used/expiry, and whether each is active/revoked/expired. Use the id with brainkb_revoke_token.

{
  "type": "object",
  "properties": {},
  "title": "brainkb_list_tokensArguments"
}

Revoke one of your Personal Access Tokens by id (see brainkb_list_tokens). Takes effect immediately — the next call using that token fails.

{
  "type": "object",
  "properties": {
    "token_id": {
      "title": "Token Id",
      "type": "integer"
    }
  },
  "required": [
    "token_id"
  ],
  "title": "brainkb_revoke_tokenArguments"
}

Use a Personal Access Token (brainkb_pat_...) for THIS session — an alternative to setting BRAINKB_TOKEN in the config. Validates the token, then caches it so subsequent calls authenticate with it. The token is never echoed.

{
  "type": "object",
  "properties": {
    "token": {
      "title": "Token",
      "type": "string"
    },
    "base_url": {
      "default": "",
      "title": "Base Url",
      "type": "string"
    }
  },
  "required": [
    "token"
  ],
  "title": "brainkb_use_tokenArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "brainkb_use_tokenOutput"
}

List spaces the user can see (their own/member spaces + public ones), each annotated with THIS caller's permission so you know what they may do: - your_role: 'owner' | 'editor' | 'viewer' | null (their space membership) - is_owner: they own the space - access: 'owner' | 'member' | 'public' (how it's available to them) - can_write: their space role permits ingest (owner/editor) — a real ingest also needs the 'ingest' capability + any per-space access rules. Use this to tell the user which spaces they can read vs. write vs. only see as public.

{
  "type": "object",
  "properties": {},
  "title": "brainkb_list_spacesArguments"
}

Create a workspace/space. The caller becomes owner. slug: lowercase/hyphen id, **globally unique** — if it's already taken the call returns 409 (pick another slug; slugs are never reused/deleted). visibility: 'private' or 'public'; description: short human description (recommended — surfaces in the registry); space_type: 'individual' (a personal space — any write-capable role) or 'team' (a shared space — only Admin/SuperAdmin, or a user granted create_team_space).

{
  "type": "object",
  "properties": {
    "slug": {
      "title": "Slug",
      "type": "string"
    },
    "name": {
      "title": "Name",
      "type": "string"
    },
    "visibility": {
      "default": "private",
      "title": "Visibility",
      "type": "string"
    },
    "description": {
      "default": "",
      "title": "Description",
      "type": "string"
    },
    "space_type": {
      "default": "individual",
      "title": "Space Type",
      "type": "string"
    }
  },
  "required": [
    "slug",
    "name"
  ],
  "title": "brainkb_create_spaceArguments"
}

Set a space 'public' (anyone, even anonymous, can read) or 'private' (members only). Owner only.

{
  "type": "object",
  "properties": {
    "slug": {
      "title": "Slug",
      "type": "string"
    },
    "visibility": {
      "title": "Visibility",
      "type": "string"
    }
  },
  "required": [
    "slug",
    "visibility"
  ],
  "title": "brainkb_set_space_visibilityArguments"
}

Add/update a space member. role: 'owner' | 'editor' | 'viewer'. Owner only.

{
  "type": "object",
  "properties": {
    "slug": {
      "title": "Slug",
      "type": "string"
    },
    "member_email": {
      "title": "Member Email",
      "type": "string"
    },
    "role": {
      "default": "viewer",
      "title": "Role",
      "type": "string"
    }
  },
  "required": [
    "slug",
    "member_email"
  ],
  "title": "brainkb_add_space_memberArguments"
}

Register a named graph and bind it to a space, so ingest/read on that graph are governed by the space's membership and visibility. Owner/editor only. The named_graph_iri is **globally unique** — one graph belongs to exactly one space. If it's already registered (to any space) the call returns 409; graph bindings are permanent (no unregister/delete).

{
  "type": "object",
  "properties": {
    "slug": {
      "title": "Slug",
      "type": "string"
    },
    "named_graph_iri": {
      "title": "Named Graph Iri",
      "type": "string"
    },
    "description": {
      "default": "",
      "title": "Description",
      "type": "string"
    }
  },
  "required": [
    "slug",
    "named_graph_iri"
  ],
  "title": "brainkb_add_space_graphArguments"
}

Ingest raw RDF text (Turtle / N-Triples / JSON-LD, auto-detected) into a named graph. Returns a job_id; ingestion runs in the background — poll with brainkb_job_status. The graph must be registered (see brainkb_add_space_graph) and the caller must have write access to its space. `sha256` / `expected_bytes` are an integrity contract, and you should use them whenever the RDF came from a file. Ingest is append-only — no delete for triples, no unregister for a graph — so RDF that arrives here mangled is permanent. Because `data` is a string, it passes through the caller's context, where dense Turtle is exactly what gets silently altered: ligatures, Greek letters, embedded newlines, escaped quotes. Declare the digest of the bytes you MEANT to send (`shasum -a 256 file.ttl`) and this refuses the write on any mismatch, turning an unrecoverable corruption into a clean rejection.

{
  "type": "object",
  "properties": {
    "named_graph_iri": {
      "title": "Named Graph Iri",
      "type": "string"
    },
    "data": {
      "title": "Data",
      "type": "string"
    },
    "sha256": {
      "default": "",
      "title": "Sha256",
      "type": "string"
    },
    "expected_bytes": {
      "default": 0,
      "title": "Expected Bytes",
      "type": "integer"
    }
  },
  "required": [
    "named_graph_iri",
    "data"
  ],
  "title": "brainkb_ingest_textArguments"
}

List RDF files YOU have staged with POST /upload but not yet ingested. Shows each upload_id, its size, sha256 and when it expires. Only your own uploads are visible.

{
  "type": "object",
  "properties": {},
  "title": "brainkb_list_uploadsArguments"
}

State of one of your staged/submitted uploads. `state` is `staged` (waiting for brainkb_ingest_upload), `submitting` (the server is streaming it to the ingest API), `submitted` (accepted — `job_id` is set, poll brainkb_job_status) or `failed` (the staged bytes were KEPT, so retry with brainkb_ingest_upload rather than re-uploading).

{
  "type": "object",
  "properties": {
    "upload_id": {
      "title": "Upload Id",
      "type": "string"
    }
  },
  "required": [
    "upload_id"
  ],
  "title": "brainkb_upload_statusArguments"
}

Delete one of your staged uploads without ingesting it.

{
  "type": "object",
  "properties": {
    "upload_id": {
      "title": "Upload Id",
      "type": "string"
    }
  },
  "required": [
    "upload_id"
  ],
  "title": "brainkb_discard_uploadArguments"
}

Ingest a file you staged with `POST /upload` into a named graph. This is the route for a large local file: your HTTP client streams the bytes straight to this server over HTTPS, then you name the resulting upload_id here. The server reads its own staged copy and posts it to the ingest API internally, so the RDF never passes through a model's context — nothing to transcribe, no context-window ceiling, and no reason to split the document (splitting breaks blank-node identity and silently detaches triples, permanently). Stage a file with any HTTP client — the point is that the LIBRARY reads the file, so the bytes never pass through a model: import requests, hashlib, pathlib f = pathlib.Path("review.ttl") r = requests.post( "https://mcp.brainkb.org/upload", params={"filename": f.name, "sha256": hashlib.sha256(f.read_bytes()).hexdigest()}, headers={"Authorization": f"Bearer {TOKEN}"}, data=f.open("rb"), # streamed — never loaded into memory ) print(r.json()) # -> {"upload_id": "up_...", "state": "staged"} It returns an upload_id and the sha256 the server computed — compare it with your own before ingesting. Returns a job_id; poll brainkb_job_status, then reconcile brainkb_delta(job_id) against the triple count you expected. The staged copy is deleted once the ingest API has accepted the bytes.

{
  "type": "object",
  "properties": {
    "named_graph_iri": {
      "title": "Named Graph Iri",
      "type": "string"
    },
    "upload_id": {
      "title": "Upload Id",
      "type": "string"
    }
  },
  "required": [
    "named_graph_iri",
    "upload_id"
  ],
  "title": "brainkb_ingest_uploadArguments"
}

Ingest local RDF files (ttl/nt/nq/rdf/owl/jsonld/json) into a named graph. Returns a job_id; runs in the background — poll with brainkb_job_status.

{
  "type": "object",
  "properties": {
    "named_graph_iri": {
      "title": "Named Graph Iri",
      "type": "string"
    },
    "file_paths": {
      "items": {
        "type": "string"
      },
      "title": "File Paths",
      "type": "array"
    },
    "max_concurrency": {
      "default": 8,
      "title": "Max Concurrency",
      "type": "integer"
    }
  },
  "required": [
    "named_graph_iri",
    "file_paths"
  ],
  "title": "brainkb_ingest_filesArguments"
}

List the user's ingest jobs (newest first) with status and progress.

{
  "type": "object",
  "properties": {
    "limit": {
      "default": 50,
      "title": "Limit",
      "type": "integer"
    }
  },
  "title": "brainkb_list_jobsArguments"
}

Detailed status of one ingest job: status, progress %, current file/stage, per-file failures, and (when complete) a summary.

{
  "type": "object",
  "properties": {
    "job_id": {
      "title": "Job Id",
      "type": "string"
    }
  },
  "required": [
    "job_id"
  ],
  "title": "brainkb_job_statusArguments"
}

Attempt to recover a stuck/errored ingest job (marks it recoverable/errored).

{
  "type": "object",
  "properties": {
    "job_id": {
      "title": "Job Id",
      "type": "string"
    }
  },
  "required": [
    "job_id"
  ],
  "title": "brainkb_recover_jobArguments"
}

Full-text search over the knowledge graphs, access-filtered by space visibility. Pass `space` to scope to one workspace, omit for a full search. Anonymous/other users never see private-space data.

{
  "type": "object",
  "properties": {
    "q": {
      "title": "Q",
      "type": "string"
    },
    "space": {
      "default": "",
      "title": "Space",
      "type": "string"
    },
    "limit": {
      "default": 25,
      "title": "Limit",
      "type": "integer"
    },
    "offset": {
      "default": 0,
      "title": "Offset",
      "type": "integer"
    }
  },
  "required": [
    "q"
  ],
  "title": "brainkb_searchArguments"
}

Read all RDF (JSON-LD) in a space's graphs. Public spaces are readable by anyone; private spaces require membership.

{
  "type": "object",
  "properties": {
    "slug": {
      "title": "Slug",
      "type": "string"
    }
  },
  "required": [
    "slug"
  ],
  "title": "brainkb_read_spaceArguments"
}

List registered named graphs visible to the caller (private-space graphs the caller can't access are hidden).

{
  "type": "object",
  "properties": {},
  "title": "brainkb_list_registered_graphsArguments"
}

Run an arbitrary SPARQL query. Requires an Admin/SuperAdmin role (the sparql_admin capability) — for ordinary questions prefer brainkb_search, brainkb_read_space, or the provenance/delta tools, which need no admin role.

{
  "type": "object",
  "properties": {
    "sparql_query": {
      "title": "Sparql Query",
      "type": "string"
    }
  },
  "required": [
    "sparql_query"
  ],
  "title": "brainkb_sparqlArguments"
}

PROV-O provenance bundle (JSON-LD) for one ingest job.

{
  "type": "object",
  "properties": {
    "job_id": {
      "title": "Job Id",
      "type": "string"
    }
  },
  "required": [
    "job_id"
  ],
  "title": "brainkb_provenance_jobArguments"
}

PROV-O ingestion/activity history (JSON-LD) for a named graph.

{
  "type": "object",
  "properties": {
    "named_graph_iri": {
      "title": "Named Graph Iri",
      "type": "string"
    }
  },
  "required": [
    "named_graph_iri"
  ],
  "title": "brainkb_provenance_graphArguments"
}

The exact triples a job added (its delta), as JSON-LD.

{
  "type": "object",
  "properties": {
    "job_id": {
      "title": "Job Id",
      "type": "string"
    }
  },
  "required": [
    "job_id"
  ],
  "title": "brainkb_deltaArguments"
}

A named graph's change history: one entry per ingest delta (job, triple count, timestamp), newest first.

{
  "type": "object",
  "properties": {
    "named_graph_iri": {
      "title": "Named Graph Iri",
      "type": "string"
    }
  },
  "required": [
    "named_graph_iri"
  ],
  "title": "brainkb_delta_historyArguments"
}

Compare two jobs' deltas: A-only / B-only / shared triple counts + triples.

{
  "type": "object",
  "properties": {
    "job_id_a": {
      "title": "Job Id A",
      "type": "string"
    },
    "job_id_b": {
      "title": "Job Id B",
      "type": "string"
    }
  },
  "required": [
    "job_id_a",
    "job_id_b"
  ],
  "title": "brainkb_delta_compareArguments"
}

(Admin only) Show a user's roles, effective capabilities, and delegated grants. Useful to check why someone can/can't create team spaces, ingest, etc.

{
  "type": "object",
  "properties": {
    "member": {
      "title": "Member",
      "type": "string"
    }
  },
  "required": [
    "member"
  ],
  "title": "brainkb_capabilitiesArguments"
}

(Admin only) Delegate a capability to a user — e.g. 'create_team_space' or 'manage_team_space' so a Curator/Lab Member can create/manage team spaces. Grantable: create_private_space, create_team_space, manage_team_space, ingest, recover, read_private (NOT the admin-only 'grant'/'sparql_admin').

{
  "type": "object",
  "properties": {
    "member": {
      "title": "Member",
      "type": "string"
    },
    "capability": {
      "title": "Capability",
      "type": "string"
    }
  },
  "required": [
    "member",
    "capability"
  ],
  "title": "brainkb_grant_capabilityArguments"
}

(Admin only) Revoke a previously granted capability from a user.

{
  "type": "object",
  "properties": {
    "member": {
      "title": "Member",
      "type": "string"
    },
    "capability": {
      "title": "Capability",
      "type": "string"
    }
  },
  "required": [
    "member",
    "capability"
  ],
  "title": "brainkb_revoke_capabilityArguments"
}

(Admin only) Catalog of all KG capabilities, which are delegatable ('grantable'), which are admin-only, and a description of each. Use this to see the available permission options before granting to a user or group/role.

{
  "type": "object",
  "properties": {},
  "title": "brainkb_list_capabilitiesArguments"
}

(Admin only) List the capabilities granted to a role/group (e.g. 'uk_collaborator', 'Lab Member').

{
  "type": "object",
  "properties": {
    "role": {
      "title": "Role",
      "type": "string"
    }
  },
  "required": [
    "role"
  ],
  "title": "brainkb_role_capabilitiesArguments"
}

(Admin only) Grant a capability to a whole role/group so EVERY member gets it — e.g. give a custom group 'uk_collaborator' the 'ingest' or 'create_private_space' capability. Grantable: create_private_space, create_team_space, manage_team_space, ingest, recover, read_private (NOT the admin-only 'grant'/'sparql_admin'). Create the group first with brainkb_create_role, then assign it to users with brainkb_assign_role.

{
  "type": "object",
  "properties": {
    "role": {
      "title": "Role",
      "type": "string"
    },
    "capability": {
      "title": "Capability",
      "type": "string"
    }
  },
  "required": [
    "role",
    "capability"
  ],
  "title": "brainkb_grant_role_capabilityArguments"
}

(Admin only) Revoke a capability from a role/group.

{
  "type": "object",
  "properties": {
    "role": {
      "title": "Role",
      "type": "string"
    },
    "capability": {
      "title": "Capability",
      "type": "string"
    }
  },
  "required": [
    "role",
    "capability"
  ],
  "title": "brainkb_revoke_role_capabilityArguments"
}

List a space's fine-grained access rules (member/manager of the space).

{
  "type": "object",
  "properties": {
    "slug": {
      "title": "Slug",
      "type": "string"
    }
  },
  "required": [
    "slug"
  ],
  "title": "brainkb_list_access_rulesArguments"
}

(Space manager) Restrict a space action to a subject. action: 'read' | 'write' | 'manage'. subject_type: 'global_role' (e.g. 'Admin','Lab Member') | 'member' (an email) | 'space_role' ('viewer'|'editor'|'owner', matched as >=). When rules exist for an action, only matching callers may perform it; the space owner and Admin/SuperAdmin always bypass (no lockout). Example: restrict writing to Admins -> action='write', subject_type='global_role', subject_value='Admin'.

{
  "type": "object",
  "properties": {
    "slug": {
      "title": "Slug",
      "type": "string"
    },
    "action": {
      "title": "Action",
      "type": "string"
    },
    "subject_type": {
      "title": "Subject Type",
      "type": "string"
    },
    "subject_value": {
      "title": "Subject Value",
      "type": "string"
    }
  },
  "required": [
    "slug",
    "action",
    "subject_type",
    "subject_value"
  ],
  "title": "brainkb_add_access_ruleArguments"
}

(Space manager) Delete a fine-grained access rule by its id (see brainkb_list_access_rules).

{
  "type": "object",
  "properties": {
    "slug": {
      "title": "Slug",
      "type": "string"
    },
    "rule_id": {
      "title": "Rule Id",
      "type": "integer"
    }
  },
  "required": [
    "slug",
    "rule_id"
  ],
  "title": "brainkb_remove_access_ruleArguments"
}

(Admin) List users (profiles) — filter by `q` (name/email/orcid) or `role`. Shows profile_id, email, roles, providers, ban status.

{
  "type": "object",
  "properties": {
    "q": {
      "default": "",
      "title": "Q",
      "type": "string"
    },
    "role": {
      "default": "",
      "title": "Role",
      "type": "string"
    },
    "limit": {
      "default": 50,
      "title": "Limit",
      "type": "integer"
    }
  },
  "title": "brainkb_list_usersArguments"
}

(Admin) List the available roles/groups (Admin, Lab Member, Curator, …).

{
  "type": "object",
  "properties": {},
  "title": "brainkb_available_rolesArguments"
}

(Admin) Create a new role/group — e.g. an 'External' collaborator group — which can then be assigned with brainkb_assign_role.

{
  "type": "object",
  "properties": {
    "name": {
      "title": "Name",
      "type": "string"
    },
    "category": {
      "default": "Content",
      "title": "Category",
      "type": "string"
    },
    "description": {
      "default": "",
      "title": "Description",
      "type": "string"
    }
  },
  "required": [
    "name"
  ],
  "title": "brainkb_create_roleArguments"
}

(Admin) Assign a role/group to a user by email (e.g. 'Lab Member', 'External', or a custom group). The user must already have a profile (created on first login/registration). NOTE: assigning the 'Admin'/'SuperAdmin' role is SuperAdmin-only (hierarchy: SuperAdmin > Admin).

{
  "type": "object",
  "properties": {
    "email": {
      "title": "Email",
      "type": "string"
    },
    "role": {
      "title": "Role",
      "type": "string"
    }
  },
  "required": [
    "email",
    "role"
  ],
  "title": "brainkb_assign_roleArguments"
}

(Admin) Remove a role/group from a user by email.

{
  "type": "object",
  "properties": {
    "email": {
      "title": "Email",
      "type": "string"
    },
    "role": {
      "title": "Role",
      "type": "string"
    }
  },
  "required": [
    "email",
    "role"
  ],
  "title": "brainkb_remove_roleArguments"
}

(Admin) Activate a user's account (sets the JWT user active) by email.

{
  "type": "object",
  "properties": {
    "email": {
      "title": "Email",
      "type": "string"
    }
  },
  "required": [
    "email"
  ],
  "title": "brainkb_activate_userArguments"
}

(Admin) Deactivate a user's account by email.

{
  "type": "object",
  "properties": {
    "email": {
      "title": "Email",
      "type": "string"
    }
  },
  "required": [
    "email"
  ],
  "title": "brainkb_deactivate_userArguments"
}

(Admin) Ban a user by email (reversible; preserves history). This is how accounts are removed — there is NO hard delete. Banning an Admin is SuperAdmin-only; SuperAdmin accounts cannot be banned.

{
  "type": "object",
  "properties": {
    "email": {
      "title": "Email",
      "type": "string"
    },
    "reason": {
      "title": "Reason",
      "type": "string"
    }
  },
  "required": [
    "email",
    "reason"
  ],
  "title": "brainkb_ban_userArguments"
}

(Admin) Lift a ban on a user by email.

{
  "type": "object",
  "properties": {
    "email": {
      "title": "Email",
      "type": "string"
    }
  },
  "required": [
    "email"
  ],
  "title": "brainkb_unban_userArguments"
}

(Admin) List all usermanagement permissions (resource/action pairs used for page-access and role-permission mapping). These are the addable 'permission' options; KG action-capabilities are listed by brainkb_list_capabilities.

{
  "type": "object",
  "properties": {},
  "title": "brainkb_list_permissionsArguments"
}

(Admin) Create a new usermanagement permission, e.g. name='dataset.export', resource='dataset', action='export'. Attach it to roles via the usermanagement role-permissions API.

{
  "type": "object",
  "properties": {
    "name": {
      "title": "Name",
      "type": "string"
    },
    "resource": {
      "title": "Resource",
      "type": "string"
    },
    "action": {
      "title": "Action",
      "type": "string"
    },
    "description": {
      "default": "",
      "title": "Description",
      "type": "string"
    }
  },
  "required": [
    "name",
    "resource",
    "action"
  ],
  "title": "brainkb_create_permissionArguments"
}