4,500+ servers built on MCP Fusion
Vinkius

Cerbos MCP. Audit policies and manage access rights via conversation.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Cerbos (Access Control) MCP on Cursor AI Code Editor MCP Client Cerbos (Access Control) MCP on Claude Desktop App MCP Integration Cerbos (Access Control) MCP on OpenAI Agents SDK MCP Compatible Cerbos (Access Control) MCP on Visual Studio Code MCP Extension Client Cerbos (Access Control) MCP on GitHub Copilot AI Agent MCP Integration Cerbos (Access Control) MCP on Google Gemini AI MCP Integration Cerbos (Access Control) MCP on Lovable AI Development MCP Client Cerbos (Access Control) MCP on Mistral AI Agents MCP Compatible Cerbos (Access Control) MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Cerbos (Access Control) MCP Server lets your AI client manage and audit policies, schemas, and permissions. Check if a user can perform an action (`check_resources`), plan complex database filters (`plan_resources`), or modify the policy rules themselves (`add_policy`).

It handles the entire authorization lifecycle—from development testing to compliance auditing.

What your AI agents can do

Add policy

Adds a brand new access policy to your system.

Add schema

Adds or updates the definition of a resource schema.

Authzen evaluation

Runs a single check for access using the AuthZEN evaluation engine.

+ 16 more capabilities included
Verify User Permissions

Checks if a specific user (principal) has the rights to perform an action on a given resource using check_resources.

Generate Filter Plans

Creates an Abstract Syntax Tree (AST) query plan using plan_resources to filter database results based on complex policy rules.

Manage Policy Definitions

Allows the listing, adding, updating, enabling, or disabling of policies using tools like list_policies, add_policy, and update_policy.

Audit Access Records

Retrieves detailed records of past access attempts and policy changes using list_audit_logs.

Inspect Resource Structure

Retrieves the defined structure and metadata for any resource using get_schema.

Monitor System Status

Checks the operational health and performance metrics of the Cerbos policy engine using get_health and get_metrics.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Cerbos (Access Control) MCP Server: 19 Tools

Manage policies, schemas, and audit logs using AI agents. The tools allow you to manage the full lifecycle of access control logic.

add019e3875

add policy

Adds a brand new access policy to your system.

add019e3875

add schema

Adds or updates the definition of a resource schema.

authzen019e3875

authzen evaluation

Runs a single check for access using the AuthZEN evaluation engine.

authzen019e3875

authzen evaluations

Runs multiple checks for access using the AuthZEN evaluation engine.

check019e3875

check resources

Checks if a user has the necessary permissions for a set of specified resources.

delete019e3875

delete policy

Removes an existing policy entirely by its unique ID.

disable019e3875

disable policy

Temporarily disables a policy without deleting it.

enable019e3875

enable policy

Activates a previously disabled policy.

get019e3875

get authzen config

Retrieves metadata about the AuthZEN configuration.

get019e3875

get health

Checks the current operational status and health of the Cerbos server.

get019e3875

get metrics

Gets performance data and Prometheus metrics from the Cerbos engine.

get019e3875

get policy

Retrieves the full details of a single policy using its ID.

get019e3875

get schema

Retrieves the structure and details of a single resource schema by ID.

get019e3875

get server info

Gets the version and build information for the Cerbos server instance.

list019e3875

list audit logs

Fetches a paginated list of all recorded access control audit logs.

list019e3875

list policies

Lists all active and inactive policies currently defined in the system.

list019e3875

list schemas

Lists all defined resource schemas available in the system.

plan019e3875

plan resources

Generates an Abstract Syntax Tree (AST) query plan for filtering resources based on policy rules.

update019e3875

update policy

Modifies the content or parameters of an existing policy.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with Cerbos (Access Control), then connect any of our 4,500+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,500+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

Hey, so this Cerbos server lets your AI client manage and audit all your access policies directly. You don't gotta manually call APIs for every permission check anymore. Your agent treats authorization like any other data task. It handles the whole authorization lifecycle, from testing development rules to compliance audits.

Checking Permissions: Your agent uses check_resources to verify if a user has the necessary rights for a specific resource. You can run multiple checks using authzen_evaluations or a single check with authzen_evaluation. You can also see if a user can act on a resource by checking the rules with check_resources.

Planning Queries: If you need to filter database results based on complex policy rules, run plan_resources. This generates an Abstract Syntax Tree (AST) query plan, letting you see the logic before the query actually runs.

Managing Policies and Schemas: You can list all current policies using list_policies, and you can retrieve the full details of any single policy with get_policy. Need to change something? Use update_policy to modify existing policies, or use add_policy to define a brand new access policy. You can also temporarily disable a policy with disable_policy or activate it with enable_policy.

If a policy is stale, you can delete it entirely using delete_policy. Similarly, you can list all resource schemas with list_schemas, get the structure of a single resource using get_schema, and update definitions with add_schema.

Auditing and Monitoring: To prove compliance, you can pull a list of all recorded access control audit logs using list_audit_logs. You'll also get performance data and Prometheus metrics via get_metrics. You can check the current operational status and health of the Cerbos server using get_health, and you'll always know the server version with get_server_info.

Other Tools: You can get metadata about the AuthZEN configuration using get_authzen_config and you can find out what policies are currently defined by running list_policies.

Basically, your agent can list all defined policies and schemas, check if a user can do what they wanna do, plan complex filters, and manage the rules that govern it all. It's a full-service policy playground built right into your chat.

How Cerbos MCP Works

  1. 1 Subscribe to the server and provide your Cerbos PDP URL and necessary admin credentials.
  2. 2 Ask your AI client to perform a task (e.g., 'Does user X have rights to delete resource Y?').
  3. 3 The agent invokes the relevant tool (like check_resources), and the server returns the final decision to your agent.

The bottom line is: your AI client handles the entire authorization stack through natural language, making the underlying API calls invisible to you.

Who Is Cerbos MCP For?

Security Engineers who need to audit policies fast. Backend Developers who write complex access logic. Compliance Officers who need proof of adherence. If your job involves knowing who can access what, this is for you.

Security Engineer

Runs list_policies and list_audit_logs to verify existing policy coverage and check for gaps in access control.

Backend Developer

Uses plan_resources during development to test complex authorization filtering before writing database queries.

Compliance Officer

Retrieves and verifies policy definitions (get_policy) and audit logs (list_audit_logs) to prove adherence to corporate security standards.

What Changes When You Connect

  • Stop writing boilerplate API calls. Your AI client handles complex authorization logic—like checking permissions with check_resources—in a single, natural language prompt.
  • Test authorization rules before deployment. Use plan_resources to generate an AST query plan, confirming exactly how the database will filter data based on policy.
  • Maintain a full audit trail. Running list_audit_logs gives you a clear record of every access attempt, which is critical for compliance reporting.
  • Manage your governance model instantly. Tools like list_policies, add_policy, and update_policy let you adjust rules and schemas directly from your chat interface.
  • Keep the system running. Use get_health and get_metrics to monitor the PDP status and performance without leaving your agent environment.
  • Test all access methods. Run authzen_evaluation or authzen_evaluations to check access against multiple rulesets in one go.

Real-World Use Cases

01

Compliance Audit: Finding a Policy Gap

A compliance officer needs to prove that the 'financial' resource can only be accessed by 'managers'. Instead of running three separate API calls (list policies, get schema, list audit logs), they ask their agent. The agent runs list_policies and list_audit_logs, confirming the rule exists and that no unauthorized access has been logged.

02

Feature Development: Filtering for a Specific User

A backend developer needs to build a query that only shows documents owned by the current user and are marked 'active'. They run plan_resources first. The agent returns an AST plan, allowing the developer to see the exact database filters required, preventing a runtime bug.

03

Debugging Access: Checking a User's Rights

A developer is unsure if a new 'admin' role can delete a resource type. They use check_resources with the specific user, action, and resource. The agent immediately confirms 'ALLOWED' or 'DENIED' based on the live policy configuration.

04

System Maintenance: Updating a Policy

The security team needs to change the retention period for one resource type. They use get_policy to pull the current rule, modify it, and then run update_policy to deploy the fix. Everything is logged via list_audit_logs.

The Tradeoffs

Ignoring the policy lifecycle

Running check_resources and getting a 'DENIED' result, then assuming the policy is wrong. The developer tries to fix it by manually calling add_policy without checking if the policy was already disabled.

Always verify the current state first. Use list_policies to see all defined policies, then use get_policy to retrieve the specific policy ID, and finally, use update_policy to make changes. This prevents accidental policy overwrites.

Confusing resource listing with planning

Trying to get a list of resources that meet a complex filter (e.g., 'all documents owned by me that are pending'). Running list_schemas only gives you the structure, not the filtered data.

You need to generate a query plan. Use plan_resources first. This produces the necessary AST structure for filtering, which you can then use to build your final query.

Assuming immediate policy effect

Calling add_policy and immediately assuming the new rule is active for all users. The policy might need to be explicitly enabled first.

After adding or updating a policy, always check the status. Use list_policies to confirm the policy is listed, and then use enable_policy to make sure the rule is live.

When It Fits, When It Doesn't

Use this server if your primary need is proving who can do what in your application. It's essential when you need to manage access rules (RBAC/ABAC) or when you need to generate database query plans based on complex rules. Don't use this if you just need to read simple data (e.g., retrieving a single user profile). If your goal is simply to query raw data, stick to a database connector. If your goal is to enforce or audit the rules around the data, use Cerbos. Use check_resources for immediate checks; use plan_resources when you need the query structure itself.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Cerbos. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 19 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

add_policy add_schema authzen_evaluation authzen_evaluations check_resources delete_policy disable_policy enable_policy get_authzen_config get_health get_metrics get_policy get_schema get_server_info list_audit_logs list_policies list_schemas plan_resources update_policy

Tracking who can access what shouldn't require jumping between five different admin dashboards.

Today, figuring out access control means logging into the admin UI, clicking 'Policies,' finding the resource, then jumping to 'Audit Logs' to see who failed and why. You copy IDs, you open tabs, and you spend 20 minutes just gathering the necessary evidence.

With the Cerbos MCP Server, you just ask your agent: 'Show me all policies that restrict access to the 'financial' resource, and show me the last three attempts to bypass it.' The agent runs `list_policies` and `list_audit_logs`, giving you a consolidated report immediately.

Cerbos MCP Server: Audit access logs with list_audit_logs.

Manually compiling audit reports involves filtering logs by date, user, and resource type across multiple log streams. It's slow, prone to missing entries, and takes dedicated manual effort.

Now, you tell your agent to 'List all failed access attempts for the 'HR' resource last week.' The agent calls `list_audit_logs` and returns the precise, filtered list. You get the data, not the effort.

Common Questions About Cerbos MCP

How do I check if a user has permission using check_resources? +

You ask your agent to run check_resources. It handles the inputs and tells you if the action is ALLOWED or DENIED based on the live policy set. This is the fastest way to validate user rights.

Can I use plan_resources to build a complex database query? +

Yes. plan_resources takes your complex filtering requirements and outputs an AST query plan. This plan shows the exact structure needed to filter your database results based on the policy logic.

What's the difference between list_policies and get_policy? +

Use list_policies when you need an overview of all policies (active, inactive, etc.). Use get_policy when you know the exact ID and only need to view the details of one specific policy.

How do I see if the Cerbos server is running correctly? Use get_health. +

Running get_health returns the current operational status of the Policy Decision Point. This confirms all systems are running and the policy engine is active.

How do I list all existing policies using list_policies? +

The list_policies tool fetches every active policy in your Cerbos instance. This list includes policy IDs and names, letting you see everything that governs resource access.

What is the best way to audit past access decisions using list_audit_logs? +

The list_audit_logs tool pulls a record of all past access checks. You can filter these logs by user, resource, or date to confirm who accessed what and when.

If I need to update an existing policy, which tool should I use? Is it `update_policy`? +

Use the update_policy tool. It lets you modify the rules or logic of a policy without having to delete and recreate it. Just provide the ID and the new definition.

How can I get metadata about the available schemas using list_schemas? +

The list_schemas tool returns a list of all defined resource schemas. This helps you understand the structure of the data (like fields and types) that policies can reference.

Can I test if a specific user has access to a resource without writing code? +

Yes. You can ask the agent to use the check_resources tool by providing the principal (user) details and the resource you want to check. The agent will return the allowed or denied status based on your Cerbos policies.

How do I view all the authorization policies currently loaded in my Cerbos server? +

Simply ask the agent to 'list all policies'. It will invoke the list_policies tool (requires Admin credentials) and display the IDs of all active policies in your environment.

Can the AI help me generate filters for my database based on permissions? +

Yes, by using the plan_resources tool. The agent will generate a query plan (AST) that describes the conditions under which a user is allowed to access resources, which you can then apply to your database queries.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 19 tools

We've already built the connector for Cerbos. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 19 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.