Skip to main content
Glama
@vengtoo/mcp-server

@vengtoo/mcp-server

by vengtoo

@vengtoo/mcp-server

Early access — 0.x releases may have breaking changes. Pin your version if stability matters.

Manage your Vengtoo authorization model and check access through any MCP-compatible AI tool.

Exposes your Vengtoo tenant as MCP tools — create resource types, subjects, roles, and policies; assign them; and check authorization decisions — all from a conversation.

Install

First, create an API key in the Vengtoo dashboard under Settings → API Access. Then add the server to your MCP client config (Claude Code, Cursor, Windsurf, Cline, or any MCP-compatible tool):

{
  "mcpServers": {
    "vengtoo": {
      "command": "npx",
      "args": ["@vengtoo/mcp-server"],
      "env": {
        "VENGTOO_API_KEY": "vgt_..."
      }
    }
  }
}

Or with OAuth2 client credentials:

{
  "mcpServers": {
    "vengtoo": {
      "command": "npx",
      "args": ["@vengtoo/mcp-server"],
      "env": {
        "VENGTOO_CLIENT_ID": "client_...",
        "VENGTOO_CLIENT_SECRET": "vgt_cs_..."
      }
    }
  }
}

Claude Code shortcut:

claude mcp add vengtoo -e VENGTOO_API_KEY=vgt_... -- npx @vengtoo/mcp-server

Related MCP server: volcengine-mcp-server

Local build (development)

npm install
npm run build
node dist/index.js

Point at a local agent instead of cloud:

"env": {
  "VENGTOO_API_KEY": "vgt_...",
  "VENGTOO_BASE_URL": "http://localhost:8181"
}

Tools

Tool

What it does

list_resource_types / create_resource_type / get_resource_type / delete_resource_type

Resource type management

list_resources / create_resource / get_resource / delete_resource

Resource management

list_subjects / create_subject / get_subject / delete_subject

Subject management

assign_role_to_subject / unassign_role_from_subject

Role membership

list_roles / create_role / get_role / delete_role

Role management

list_policies / create_policy / get_policy / delete_policy

Policy management

assign_policy / unassign_policy

Policy assignment (with optional starts_at/expires_at for JIT access)

evaluate_access

Evaluate whether a subject can perform an action on a resource

list_pending_tools / approve_tool / block_tool

MCP governance — review, then approve or block the tools an AI agent can call through a gateway

Environment variables

Variable

Required

Description

VENGTOO_API_KEY

One of these two

API key starting with vgt_. Create one in the dashboard under Settings → API Access

VENGTOO_CLIENT_ID + VENGTOO_CLIENT_SECRET

One of these two

OAuth2 client credentials

VENGTOO_BASE_URL

No

Override API base URL. Default: https://api.vengtoo.com

Docs

vengtoo.com/docs

License

MIT

Available Tools

29 tools
assign_policyA

Assign a policy to a subject, role, or group. This is what actually grants access — creating a policy alone does nothing until it is assigned.

entity_type must be "subject", "role", or "group".

For time-boxed (JIT) access: set expires_at. For future-dated access: also set starts_at.

Inputs: entity_id (required), policy_id (required), entity_type (required), starts_at, +1 more.

assign_role_to_subjectA

Give a subject a role. The subject inherits all policies assigned to the role. Use this to build RBAC: create a role, assign policies to it, then assign the role to subjects.

Inputs: role_id (required), subject_id (required).

check_authorizationA

Ask Vengtoo whether a subject can perform an action on a resource. Returns decision: true (allowed) or false (denied), plus the reason and which policy/access path was responsible.

Identify the subject and resource using either their Vengtoo UUID (id) or your system's own identifier (external_id). external_id is preferred in production — it avoids the need to store Vengtoo UUIDs.

For type-level checks (does this user have ANY access to this type of resource?): set resource_type and omit resource_id and resource_external_id. For instance-level checks (does this user have access to THIS specific resource?): set resource_id or resource_external_id.

Inputs: action (required), subject_type (required), resource_type (required), subject_id, +3 more.

create_namespaceA

Create a new namespace. Resources created inside this namespace are isolated from resources in other namespaces. Use "default" namespace unless you specifically need isolation.

Inputs: name (required), description.

create_policyA

Create a policy. A policy grants or denies a set of actions on a resource type (type-level) or a specific resource (instance-level). After creating, assign it to a subject or role with assign_policy.

For type-level: set resource_type_id and actions — the policy applies to ALL resources of that type. For instance-level: set resource_id and actions — the policy applies to ONE specific resource.

Inputs: name (required), effect (required), actions (required), priority, +3 more.

create_resourceA

Create a resource — a specific instance of a resource type (e.g. a specific document, a specific project). Set external_id to your system's own identifier (database UUID, slug) so you can reference it at evaluation time without storing Vengtoo's internal ID.

Inputs: name (required), type (required), description, external_id.

create_resource_typeA

Create a resource type. Do this before creating resources or policies. The actions list defines what verbs are valid for this type (e.g. ["read", "write", "delete"]). Policies targeting this type use these action names.

Inputs: name (required), actions (required), description.

create_roleA

Create a role. After creating it, assign policies to the role with assign_policy (entity_type: "role"), then assign subjects to the role with assign_role_to_subject.

Inputs: name (required), description.

create_subjectA

Create a subject — any principal that can be authorized (user, service, AI agent, device). Set external_id to your system's own user/service identifier so evaluation calls can reference it without a Vengtoo UUID lookup.

Inputs: name (required), type (required), external_id.

delete_namespaceA

Delete a namespace by ID. This does not delete the resources inside it.

Inputs: id (required).

delete_policyA

Delete a policy by ID. Subjects or roles that had this policy assigned immediately lose the access it granted.

Inputs: id (required).

delete_resourceC

Delete a resource by ID.

Inputs: id (required).

delete_resource_typeB

Delete a resource type by ID.

Inputs: id (required).

delete_roleA

Delete a role by ID. Subjects who had this role lose any access that came exclusively from it.

Inputs: id (required).

delete_subjectB

Delete a subject by ID.

Inputs: id (required).

get_namespaceC

Get a namespace by ID.

Inputs: id (required).

get_policyA

Get a policy by ID, including its resource and action assignments.

Inputs: id (required).

get_resourceC

Get a resource by ID.

Inputs: id (required).

get_resource_typeC

Get a resource type by ID.

Inputs: id (required).

get_roleB

Get a role by ID.

Inputs: id (required).

get_subjectC

Get a subject by ID.

Inputs: id (required).

list_namespacesA

List all namespaces in the tenant. Namespaces are optional containers that scope resources — useful when the same resource type name is used across multiple isolated environments (e.g., prod vs staging).

Inputs: no named parameters.

list_policiesA

List all policies in the tenant.

Inputs: no named parameters.

list_resourcesA

List resources in the tenant.

Inputs: no named parameters.

list_resource_typesA

List all resource types. A resource type defines a category of thing you protect (e.g. "document", "project", "invoice") and the actions available on it.

Inputs: no named parameters.

list_rolesA

List all roles. Roles are named collections of policies — assign a role to many subjects instead of assigning the same policies repeatedly.

Inputs: no named parameters.

list_subjectsA

List subjects (users, services, AI agents, or any other principal) in the tenant.

Inputs: type.

unassign_policyA

Remove a policy assignment from a subject, role, or group. Access granted by this policy is revoked immediately.

Inputs: entity_id (required), policy_id (required), entity_type (required).

unassign_role_from_subjectA

Remove a role from a subject. The subject immediately loses any access that came exclusively from this role.

Inputs: role_id (required), subject_id (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 29 tools

    Disambiguation5/5

    Each tool targets a distinct operation on a specific entity (e.g., create_namespace, assign_policy, check_authorization). There is no overlap; even assignment operations are clearly separated by entity type.

    Naming Consistency5/5

    All tool names use consistent snake_case with a verb_noun pattern (e.g., create_resource, list_roles, delete_policy). Longer names like assign_role_to_subject remain descriptive and follow the pattern.

    Tool Count4/5

    With 29 tools, the count is high but justified by the comprehensive coverage of multiple entity types (namespace, policy, resource, resource_type, role, subject) and their CRUD plus assignment operations. It slightly exceeds the ideal range but remains well-scoped.

    Completeness2/5

    The tool set lacks update operations for all entities (e.g., update_policy, update_role). This forces users to delete and recreate objects to modify them, which is a significant gap for a permissions management system.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to interact with the Ceveto business management API through MCP, with permission-filtered tools and secure Ed25519 authentication.
      3
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to discover and invoke backend tools over MCP JSON-RPC while enforcing 3-legged OAuth 2.0 identity propagation, role-based access control, and protocol transcoding to REST APIs.
      1
      Apache 2.0