# Mint MCP

> MintMCP is an enterprise MCP Gateway that enforces governance and security guardrails for AI agents. It manages authentication, monitors all tool executions, and ensures compliance (SOC2/PII redaction) by routing agent workflows through centralized virtual servers. Use it when you need to restrict exactly what your LLMs can access.

## Overview
- **Category:** fort-knox
- **Price:** Free
- **Tags:** governance, security-guardrails, pii-redaction, soc2, proxy-routing

## Description

Listen up. Your LLMs are powerful, but they're also liabilities if you let them run wild against your core systems. You need a gatekeeper—a real one—to manage every single thing your AI agents touch. That's where the MintMCP server comes in. It runs as your centralized proxy layer, making sure that whether an agent reads data or tries to call a function, everything gets audited and checked for compliance first. This isn't just logging; it's control.

When you need to restrict exactly what your agents can access, you use this server. You tell your AI client to route through MintMCP, and we handle the heavy lifting of governance and security guardrails across all your backend services. It acts as a virtual barrier that keeps everything contained.

### Controlling Execution Scope

When an agent needs to perform an action, it doesn't talk directly to the source system; it talks to us. You can use **`mintmcp_run_tool_action`** to proxy and safely execute any logic stream that hits native integrations behind this gateway. This process keeps your sensitive systems completely insulated from the agent’s direct calls.

To figure out what services are even available for action, you start by looking at the abstraction layer. **`mintmcp_list_virtual_servers`** gives you a list of every proxy abstraction—these are functional groupings that bundle multiple tools together so your agents only see service names, not underlying complexity. If you need to know what specific functions fall under one of those abstractions, **`mintmcp_get_virtual_server`** extracts the exact configuration patterns for that unique Virtual Server schema.

Once you've got the list of services, you can drill down into what tools are approved inside a given server. You run **`mintmcp_list_available_tools`**, and it audits and returns every single underlying tool currently cleared for use within that specific virtual server. Crucially, you don't just get a name; you check the rules. To know exactly who can execute what, you call **`mintmcp_get_tool_policy`** to retrieve the definitive SOC2 governance and Role-Based Access Control (RBAC) parameters for any single tool integration.

### Enforcing Compliance and Redaction

We don't just track calls; we check the data itself. When an agent sends a payload, you run **`mintmcp_eval_guardrail`**. This function passes the structural parameter string through unified engines that explicitly check for PII redaction compliance. If the incoming text fails these standards—if it contains unredacted Personal Identifiable Information or violates other structural rules—the call dies immediately. You don't get a warning; you get a hard stop.

### Full Visibility and Shutting Down Threats

If something goes wrong, or if you just need to prove you’re compliant for an audit, we got your back. **`mintmcp_fetch_audit_logs`** dumps systematic telemetry logs, tracking every single access attempt against your entire SOC2 matrix and detailing all executions. You get a complete timeline of who tried to do what, and when.

And if you suspect a connection is compromised—if an agent’s session turns hostile or unauthorized—you don't wait for the damage report. You use **`mintmcp_revoke_access_token`** to immediately sever that runtime session by resolving any active OAuth flow or token, locking it out from the main host before it can cause trouble.

It’s a complete system: you see what services exist, you check if the agent has permission for those services, you verify the data is clean enough to pass, and if anything goes sideways, you kill the connection while documenting every step. You get total control over your AI environment.

## Tools

### mintmcp_eval_guardrail
Passes a structural parameter string through unified engines that check for PII redaction compliance.

### mintmcp_fetch_audit_logs
Dumps systematic telemetry logs, tracking all SOC2 matrix accesses and executions.

### mintmcp_get_tool_policy
Retrieves the specific SOC2 governance and RBAC parameters that restrict access to a single tool integration.

### mintmcp_get_virtual_server
Extracts the exact configuration patterns for one unique Virtual Server schema.

### mintmcp_list_available_tools
Audits and returns a list of all underlying tools currently approved inside a specific Virtual Server.

### mintmcp_list_virtual_servers
Lists every available proxy abstraction, grouping multiple tools together for functional access.

### mintmcp_revoke_access_token
Immediately severs a runtime session by resolving an active OAuth flow or token.

### mintmcp_run_tool_action
Proxies and safely executes any logic stream that hits native integrations behind the gateway.

## Prompt Examples

**Prompt:** 
```
Fetch the exact list of available virtual servers configured on my organization proxy natively.
```

**Response:** 
```
Parsing proxy layers (`list_virtual_servers`). Resulting execution captured 3 dynamic topologies natively mapped to your access limitations completely securely.
```

**Prompt:** 
```
Verify the PI redaction guardrails against the textual payload 'Transfer funds using account ABC'.
```

**Response:** 
```
Sending diagnostic limits (`eval_guardrail`). Gateway engines returned cleanly verifying policies successfully triggered catching no critical parameters mapping explicitly internally.
```

**Prompt:** 
```
Poll the last 10 security audit execution logs from our native environment bounds.
```

**Response:** 
```
Fetching limit bounds array naturally spanning telemetry limits (`fetch_audit_logs`). Extracted explicit logging histories mapping exclusively native connections flawlessly secure.
```

## Capabilities

### Audit full execution history
Pull systematic logs that track every access attempt against your SOC2 matrix.

### Enforce data redaction rules
Test incoming text payloads through a unified engine to redact PII and ensure compliance standards are met.

### List available protected services
See all virtual server proxy abstractions that group your backend tools functionally.

### Check tool permissions
Fetch the definitive RBAC parameters to determine exactly who can execute a specific function.

### Isolate compromised connections
Immediately revoke active OAuth flows or runtime sessions from the main host.

## Use Cases

### Onboarding a new third-party API
A dev team wants to let an agent use a payment processing tool. They can't just plug it in. First, they call `mintmcp_get_tool_policy` to define the exact permissions. Then, they group that tool into a virtual server using `mintmcp_list_virtual_servers`. Finally, they only allow execution via `mintmcp_run_tool_action`, ensuring no direct connection is possible.

### Handling sensitive user inputs
An agent receives a chat message containing account numbers. Before the agent can process it, you run `mintmcp_eval_guardrail` on the input string. If PII is detected, the tool fails the execution before any backend data gets touched.

### Investigating an unusual access spike
A security lead notices strange activity. Instead of checking multiple dashboards, they call `mintmcp_fetch_audit_logs`. This single action pulls all telemetry and logs across the system, showing exactly which tool was called and when.

### Killing a runaway agent session
An AI client gets stuck in an infinite loop or starts spamming endpoints. You immediately call `mintmcp_revoke_access_token` to kill the OAuth flow, isolating the compromised connection from your main host.

## Benefits

- Enforce compliance before execution. Use `mintmcp_eval_guardrail` to check all incoming data against SOC2 and PII rules, stopping bad inputs instantly.
- Achieve full auditability with every call. Running `mintmcp_fetch_audit_logs` gives you a single, secure dump of every executed action for compliance reporting.
- Limit agent scope precisely. Check tool permissions using `mintmcp_get_tool_policy` to ensure the AI only has access to functions it absolutely needs.
- Manage service boundaries. Use `mintmcp_list_virtual_servers` and `mintmcp_get_virtual_server` to understand exactly how your backend services are grouped and protected.
- Contain breaches instantly. If an agent acts maliciously, call `mintmcp_revoke_access_token` to cut off the connection immediately.

## How It Works

The bottom line is you control the blast radius by making the gateway mandatory for every agent interaction.

1. First, declare your global Tenant ID matrix and API Token as MintMCP variables.
2. Next, set the context engine limits to restrict the AI strictly within native execution bounds.
3. Finally, request telemetries or run logs. This resolves matching endpoints and audits logic executions across isolated nodes.

## Frequently Asked Questions

**How do I check if an agent can run a specific function using mintmcp_get_tool_policy?**
You call `mintmcp_get_tool_policy` and pass the tool's identifier. This returns the definitive RBAC parameters, showing exactly which permissions are required for that integration.

**What is the difference between mintmcp_list_available_tools and mintmcp_list_virtual_servers?**
Listing virtual servers (`mintmcp_list_virtual_servers`) shows you the high-level, functional groups of tools. Listing available tools tells you every single specific function approved inside one of those groups.

**I need to audit old system access records using mintmcp_fetch_audit_logs.**
Use `mintmcp_fetch_audit_logs` to dump systematic telemetry logs. This action tracks every SOC2 matrix access, giving you the full history of execution.

**How do I stop a running agent session if it's misbehaving? Use mintmcp_revoke_access_token.**
Running `mintmcp_revoke_access_token` resolves and severs the active OAuth flow. This immediately isolates the connection from your main host, stopping the runaway process.

**When I run `mintmcp_eval_guardrail`, how does it handle sensitive data like PII?**
It checks structural parameters against SOC2 standards. The guardrail engine performs real-time PI redaction, preventing unauthorized leakage of critical data before the AI client processes it.

**What specific configuration details do I get when using `mintmcp_get_virtual_server`?**
You extract the exact pattern for a unique virtual server schema. This reveals the precise limitations and deployment scope of that specific proxy topology.

**How should my agent use `mintmcp_run_tool_action` to execute a critical function?**
You pass the execution logic stream directly to the gateway. The action proxies it safely, hitting native integrations without bypassing required security layers.

**If I run `mintmcp_list_virtual_servers` and don't see a server I expected, what does that mean?**
It means the proxy abstraction isn't mapped or approved for your current tenant. You need to check platform deployment status before expecting access.

**Can I test payload parameters through the security Guardrails offline?**
Yes, mapping direct values through `eval_guardrail` runs simulated queries bypassing the actual downstream proxy directly into the evaluation loop.

**Are explicit SOC2 Audit Logs available natively to query via this agent integration?**
Yes! Utilize `fetch_audit_logs` limiting explicitly standard parameters to unpack all tool executions securely bounded inside your tenant matrix natively.

**How do virtual servers separate functional tools proxy instances natively?**
By polling `list_available_tools` against a specific server ID, you extract rigidly grouped schemas bounded solely to that environment parameter.