> ## Documentation Index
> Fetch the complete documentation index at: https://veryfront.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Create project inference policy standard tier opt in

> Record that this project accepts standard-tier serving and set its minimum tier to standard.

export const McpToolCall = ({tool, initialArguments = {}, requiresConfirmation = false}) => {
  const validateCall = function validateReferenceToolCall(token, text, requiresConfirmation, confirmed) {
    if (!token.trim()) return {
      error: "Paste a bearer token first."
    };
    let value;
    try {
      value = JSON.parse(text.trim() || "{}");
    } catch {
      return {
        error: "Arguments must be valid JSON."
      };
    }
    if (!value || typeof value !== "object" || Array.isArray(value)) return {
      error: "Arguments must be a JSON object."
    };
    if (requiresConfirmation && !confirmed) return {
      error: "Confirm the tool call before running it."
    };
    return {
      arguments: value
    };
  };
  const endpoint = "https://api.veryfront.com/mcp";
  const tokenStorageKey = 'veryfront.docs.mcpBearerToken';
  const escapeHtml = value => value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
  const highlightJson = value => {
    const escaped = escapeHtml(value);
    return escaped.replace(/("(?:\\u[a-fA-F0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\btrue\b|\bfalse\b|\bnull\b|-?\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?)/g, match => {
      let color = '#f3f4f6';
      if (match.endsWith(':')) {
        color = '#7dd3fc';
      } else if (match.startsWith('"')) {
        color = '#86efac';
      } else if ((/true|false/).test(match)) {
        color = '#c4b5fd';
      } else if ((/null/).test(match)) {
        color = '#fcd34d';
      } else {
        color = '#67e8f9';
      }
      return `<span style="color: ${color}">${match}</span>`;
    });
  };
  const expandJsonStrings = value => {
    if (typeof value === 'string') {
      const trimmed = value.trim();
      if (trimmed.startsWith('{') && trimmed.endsWith('}') || trimmed.startsWith('[') && trimmed.endsWith(']')) {
        try {
          return expandJsonStrings(JSON.parse(trimmed));
        } catch {}
      }
      return value;
    }
    if (Array.isArray(value)) {
      return value.map(expandJsonStrings);
    }
    if (value && typeof value === 'object') {
      return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [key, expandJsonStrings(nestedValue)]));
    }
    return value;
  };
  const formatJson = value => {
    try {
      return JSON.stringify(expandJsonStrings(value), null, 2);
    } catch {
      return String(value);
    }
  };
  const formatResponseText = text => {
    const trimmed = text.trim();
    if (!trimmed) return 'No response body.';
    try {
      return formatJson(JSON.parse(trimmed));
    } catch {}
    const ssePayloads = trimmed.split(/\n\n+/).flatMap(chunk => chunk.split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trim()).filter(Boolean));
    for (let index = ssePayloads.length - 1; index >= 0; index -= 1) {
      try {
        return formatJson(JSON.parse(ssePayloads[index]));
      } catch {}
    }
    return trimmed;
  };
  const readStoredToken = () => {
    if (typeof window === 'undefined') return '';
    try {
      return window.sessionStorage.getItem(tokenStorageKey) || '';
    } catch {
      return '';
    }
  };
  const writeStoredToken = value => {
    if (typeof window === 'undefined') return;
    try {
      if (value) {
        window.sessionStorage.setItem(tokenStorageKey, value);
      } else {
        window.sessionStorage.removeItem(tokenStorageKey);
      }
    } catch {}
  };
  const [token, setToken] = useState(readStoredToken);
  const [argumentText, setArgumentText] = useState(formatJson(initialArguments));
  const [status, setStatus] = useState('Ready');
  const [response, setResponse] = useState('No response yet.');
  const [copied, setCopied] = useState(false);
  const [confirmed, setConfirmed] = useState(false);
  const callTool = async () => {
    const validation = validateCall(token, argumentText, requiresConfirmation, confirmed);
    if (('error' in validation)) {
      setStatus(validation.error);
      return;
    }
    const parsedArguments = validation.arguments;
    setConfirmed(false);
    const body = {
      jsonrpc: '2.0',
      id: Date.now(),
      method: 'tools/call',
      params: {
        name: tool,
        arguments: parsedArguments
      }
    };
    setStatus('Calling tool...');
    setResponse(formatJson(body));
    try {
      const result = await fetch(endpoint, {
        method: 'POST',
        headers: {
          accept: 'application/json, text/event-stream',
          'content-type': 'application/json',
          authorization: `Bearer ${token.trim()}`,
          'x-veryfront-origin': 'docs-mcp-tool-page'
        },
        body: JSON.stringify(body)
      });
      const text = await result.text();
      setStatus(result.ok ? 'Response received.' : `Request failed with HTTP ${result.status}.`);
      setResponse(formatResponseText(text));
    } catch (error) {
      setStatus('Request failed.');
      setResponse(error instanceof Error ? error.message : String(error));
    }
  };
  const copyResponse = async () => {
    try {
      await navigator.clipboard.writeText(response);
      setCopied(true);
      setTimeout(() => setCopied(false), 1500);
    } catch {
      setStatus('Copy failed.');
    }
  };
  return <details className="api-try-operation not-prose">
    <summary>Try this tool</summary>
    <p>Replace sample arguments with values for your project or connected account. Calls run only when you select Run tool.</p>
    <div className="api-request-playground not-prose my-6 rounded-xl border border-gray-200 bg-white p-4 dark:border-gray-800 dark:bg-gray-950">
      <div className="mb-4">
        <div className="text-sm font-semibold text-gray-900 dark:text-gray-100">MCP tool call</div>
        <div className="mt-1 text-sm text-gray-600 dark:text-gray-400">
          Call <code>{tool}</code> against the Veryfront MCP endpoint.
        </div>
      </div>

      <label className="mb-2 block text-sm font-medium text-gray-900 dark:text-gray-100" htmlFor={`${tool}-token`}>
        Bearer token or API key
      </label>
      <input id={`${tool}-token`} className="mb-4 w-full rounded-md border border-gray-300 bg-white px-3 py-2 text-sm text-gray-900 dark:border-gray-700 dark:bg-gray-900 dark:text-gray-100" type="password" value={token} onChange={event => {
    const value = event.target.value;
    setToken(value);
    setConfirmed(false);
    writeStoredToken(value);
  }} placeholder="Paste API key or JWT" />

      <label className="mb-2 block text-sm font-medium text-gray-900 dark:text-gray-100" htmlFor={`${tool}-arguments`}>
        Arguments (JSON)
      </label>
      <textarea id={`${tool}-arguments`} className="mb-4 min-h-40 w-full rounded-md border border-gray-300 bg-white px-3 py-2 font-mono text-sm text-gray-900 dark:border-gray-700 dark:bg-gray-900 dark:text-gray-100" value={argumentText} onChange={event => {
    setArgumentText(event.target.value);
    setConfirmed(false);
  }} spellCheck={false} />

      {requiresConfirmation && <label className="api-request-confirmation mb-4 flex items-start gap-2 text-sm">
        <input type="checkbox" checked={confirmed} onChange={event => setConfirmed(event.target.checked)} />
        <span>{tool === 'veryfront__set_project_inference_policy' ? 'Replace the project inference policy with these arguments. Omitted constraints will be removed.' : 'Run this tool with these arguments.'}</span>
      </label>}
      <button disabled={status === 'Calling tool...' || requiresConfirmation && !confirmed} className="disabled:opacity-50 disabled:cursor-not-allowed rounded-md bg-gray-900 px-3 py-2 text-sm font-medium text-white hover:bg-gray-700 dark:bg-gray-100 dark:text-gray-950 dark:hover:bg-gray-300" type="button" onClick={callTool}>
        Run tool
      </button>

      <div className="mt-4 text-sm font-medium text-gray-900 dark:text-gray-100">{status}</div>
      <div className="mt-3 overflow-hidden rounded-md border border-gray-300 dark:border-gray-700">
        <div className="flex items-center justify-between bg-gray-100 px-3 py-2 text-sm font-medium text-gray-900 dark:bg-gray-900 dark:text-gray-100">
          <span>Output JSON</span>
          <button className="rounded border border-gray-300 bg-white px-2 py-1 text-xs text-gray-900 hover:bg-gray-50 dark:border-gray-700 dark:bg-gray-950 dark:text-gray-100 dark:hover:bg-gray-800" type="button" onClick={copyResponse}>
            {copied ? 'Copied' : 'Copy'}
          </button>
        </div>
      <pre className="max-h-96 overflow-auto whitespace-pre-wrap break-words bg-gray-950 p-4 text-sm text-gray-100">
        <code dangerouslySetInnerHTML={{
    __html: highlightJson(response)
  }} />
      </pre>
      </div>
    </div>
    </details>;
};

<div className="api-operation-signature">
  `veryfront__create_project_inference_policy_standard_tier_opt_in`
</div>

Standard is the lowest tier, so this is a deliberate decision rather than an ordinary edit: the moment and the person are recorded and survive later edits of the tier floor.

Every other constraint is left as it is.

Calling it again when the project has already opted in changes nothing and does not re-date the acceptance.

Requires a signed-in project admin; an API key is refused whatever its scopes.

## Access

No external-service connection is required. Use a Veryfront credential with access to the requested resources.

**Call type:** Can change resources.

## Arguments

| Field | Type | Required | Description and constraints |
| - | - | - | - |
| `project_reference` | `string` | No | Project ID or slug |
| `confirm` | `boolean` | Yes | Must be true: standard is the lowest tier, so accepting it is a deliberate, recorded decision |

## Example request

Send this JSON-RPC request through an initialized MCP client. Replace sample identifiers and values before calling the tool. See [MCP client setup](/docs/cloud/getting-started/connect-mcp).

```json title="request.json" theme={null}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "veryfront__create_project_inference_policy_standard_tier_opt_in",
    "arguments": {
      "confirm": false
    }
  }
}
```

## Result

The published output shape is summarized below. Inspect both the MCP response content and `isError` when handling a call.

| Field | Type | Required | Description and constraints |
| - | - | - | - |
| `project_id` | `string` | Yes | Project identifier associated with this result. |
| `configured` | `boolean` | Yes | Whether a policy row exists. False means the fields below are defaults. A row that constrains nothing is routed exactly like no row; routing changes begin at the first non-null constraint. |
| `enforced` | `boolean` | Yes | Whether the gateway can apply this stored policy. True for every readable policy: each stated constraint, the "eu-resident" tier floor included, is enforced. False only when a stored value (a tier or precision) is one this build cannot read, because the gateway then refuses every request for the project instead of applying it. |
| `min_tier` | `string or null` | Yes | Returns the stored minimum tier: qualified-sovereign, eu-owned, eu-resident, or standard. Null means no stored floor and is served as "eu-resident": every project is EU-only by default. Unknown values from newer builds remain readable. |
| `min_quantization` | `string or null` | Yes | Returns the stored minimum precision: bf16, fp16, fp8, nvfp4, fp4, or int4. Null means no stored precision constraint. Unknown values from newer builds remain readable. |
| `allowed_jurisdictions` | `string[] or null` | Yes | Lists allowed operator jurisdictions as uppercase ISO 3166-1 alpha-2 codes. Null adds no jurisdiction constraint; an empty list permits none. |
| `allowed_host_ids` | `string[] or null` | Yes | Lists allowed catalog host IDs. Null adds no host allowlist constraint; an empty list permits none. |
| `denied_host_ids` | `string[] or null` | Yes | Lists denied catalog host IDs. Null or an empty list adds no host denials. Denials override allowances. |
| `allowed_models` | `string[] or null` | Yes | Lists canonical model IDs the project may use. Null adds no model allowlist constraint; an empty list permits none. |
| `denied_models` | `string[] or null` | Yes | Lists canonical model IDs the project may not use. Null or an empty list adds no model denials. Denials override allowances. |
| `standard_tier_opt_in_at` | `string or null` | Yes | Records the standard-tier acceptance timestamp in ISO 8601 format, or null when no acceptance is recorded. |
| `standard_tier_opt_in_by` | `string or null` | Yes | Records the user ID responsible for acceptance, or null when no actor is recorded. |
| `standard_tier_opt_in_source` | `string or null` | Yes | How the recorded acceptance was granted: "admin" when a project admin accepted it through this API, "grandfather" when the one-off migration recorded it for inference the project was already running before the default tier floor existed. Null when no acceptance is recorded. |
| `allow_non_eu_hosting` | `boolean` | Yes | Whether this project has opted in to non-EU hosting: the standard-tier opt-in is recorded ([`create_project_inference_policy_standard_tier_opt_in`](/docs/cloud/mcp/tools/create-project-inference-policy-standard-tier-opt-in)) and `min_tier` is "standard", which drops the default "eu-resident" floor. False by default: a project is EU-only, and a `min_tier` of null is served as "eu-resident". True does not mean the project is served outside the EU: its other constraints (for example `allowed_jurisdictions` or `allowed_host_ids`) may still restrict serving to the EU. Read-only; derived. |
| `created_at` | `string or null` | Yes | Records policy creation in ISO 8601 format, or null when no policy row exists. |
| `updated_at` | `string or null` | Yes | Records the last policy update in ISO 8601 format, or null when no policy row exists. |
| `updated_by` | `string or null` | Yes | Records the user ID responsible for the last policy update, or null when no actor is recorded. |

## Full schemas

<CodeGroup>
  ```json title="input-schema.json" theme={null}
  {
    "type": "object",
    "properties": {
      "project_reference": {
        "type": "string",
        "description": "Project ID or slug"
      },
      "confirm": {
        "type": "boolean",
        "description": "Must be true: standard is the lowest tier, so accepting it is a deliberate, recorded decision"
      }
    },
    "required": [
      "confirm"
    ],
    "additionalProperties": false,
    "description": "Arguments for the create_project_inference_policy_standard_tier_opt_in tool.",
    "$schema": "http://json-schema.org/draft-07/schema#"
  }
  ```

  ```json title="output-schema.json" theme={null}
  {
    "type": "object",
    "properties": {
      "project_id": {
        "type": "string",
        "description": "Project identifier associated with this result."
      },
      "configured": {
        "type": "boolean",
        "description": "Whether a policy row exists. False means the fields below are defaults. A row that constrains nothing is routed exactly like no row; routing changes begin at the first non-null constraint."
      },
      "enforced": {
        "type": "boolean",
        "description": "Whether the gateway can apply this stored policy. True for every readable policy: each stated constraint, the \"eu-resident\" tier floor included, is enforced. False only when a stored value (a tier or precision) is one this build cannot read, because the gateway then refuses every request for the project instead of applying it."
      },
      "min_tier": {
        "type": [
          "string",
          "null"
        ],
        "description": "Returns the stored minimum tier: qualified-sovereign, eu-owned, eu-resident, or standard. Null means no stored floor and is served as \"eu-resident\": every project is EU-only by default. Unknown values from newer builds remain readable."
      },
      "min_quantization": {
        "type": [
          "string",
          "null"
        ],
        "description": "Returns the stored minimum precision: bf16, fp16, fp8, nvfp4, fp4, or int4. Null means no stored precision constraint. Unknown values from newer builds remain readable."
      },
      "allowed_jurisdictions": {
        "anyOf": [
          {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "List of allowed jurisdictions associated with this tool result."
          },
          {
            "type": "null",
            "description": "The allowed jurisdictions returned by the tool."
          }
        ],
        "description": "Lists allowed operator jurisdictions as uppercase ISO 3166-1 alpha-2 codes. Null adds no jurisdiction constraint; an empty list permits none."
      },
      "allowed_host_ids": {
        "anyOf": [
          {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "List of allowed host ids associated with this tool result."
          },
          {
            "type": "null",
            "description": "The allowed host ids returned by the tool."
          }
        ],
        "description": "Lists allowed catalog host IDs. Null adds no host allowlist constraint; an empty list permits none."
      },
      "denied_host_ids": {
        "anyOf": [
          {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "List of denied host ids associated with this tool result."
          },
          {
            "type": "null",
            "description": "The denied host ids returned by the tool."
          }
        ],
        "description": "Lists denied catalog host IDs. Null or an empty list adds no host denials. Denials override allowances."
      },
      "allowed_models": {
        "anyOf": [
          {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "AI model ids the agent may switch between."
          },
          {
            "type": "null",
            "description": "AI model ids the agent may switch between."
          }
        ],
        "description": "Lists canonical model IDs the project may use. Null adds no model allowlist constraint; an empty list permits none."
      },
      "denied_models": {
        "anyOf": [
          {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "List of denied models associated with this tool result."
          },
          {
            "type": "null",
            "description": "The denied models returned by the tool."
          }
        ],
        "description": "Lists canonical model IDs the project may not use. Null or an empty list adds no model denials. Denials override allowances."
      },
      "standard_tier_opt_in_at": {
        "type": [
          "string",
          "null"
        ],
        "description": "Records the standard-tier acceptance timestamp in ISO 8601 format, or null when no acceptance is recorded."
      },
      "standard_tier_opt_in_by": {
        "type": [
          "string",
          "null"
        ],
        "description": "Records the user ID responsible for acceptance, or null when no actor is recorded."
      },
      "standard_tier_opt_in_source": {
        "type": [
          "string",
          "null"
        ],
        "description": "How the recorded acceptance was granted: \"admin\" when a project admin accepted it through this API, \"grandfather\" when the one-off migration recorded it for inference the project was already running before the default tier floor existed. Null when no acceptance is recorded."
      },
      "allow_non_eu_hosting": {
        "type": "boolean",
        "description": "Whether this project has opted in to non-EU hosting: the standard-tier opt-in is recorded (create_project_inference_policy_standard_tier_opt_in) and min_tier is \"standard\", which drops the default \"eu-resident\" floor. False by default: a project is EU-only, and a min_tier of null is served as \"eu-resident\". True does not mean the project is served outside the EU: its other constraints (for example allowed_jurisdictions or allowed_host_ids) may still restrict serving to the EU. Read-only; derived."
      },
      "created_at": {
        "type": [
          "string",
          "null"
        ],
        "description": "Records policy creation in ISO 8601 format, or null when no policy row exists."
      },
      "updated_at": {
        "type": [
          "string",
          "null"
        ],
        "description": "Records the last policy update in ISO 8601 format, or null when no policy row exists."
      },
      "updated_by": {
        "type": [
          "string",
          "null"
        ],
        "description": "Records the user ID responsible for the last policy update, or null when no actor is recorded."
      }
    },
    "required": [
      "project_id",
      "configured",
      "enforced",
      "min_tier",
      "min_quantization",
      "allowed_jurisdictions",
      "allowed_host_ids",
      "denied_host_ids",
      "allowed_models",
      "denied_models",
      "standard_tier_opt_in_at",
      "standard_tier_opt_in_by",
      "standard_tier_opt_in_source",
      "allow_non_eu_hosting",
      "created_at",
      "updated_at",
      "updated_by"
    ],
    "additionalProperties": false,
    "description": "Structured result returned by the create_project_inference_policy_standard_tier_opt_in tool.",
    "$schema": "http://json-schema.org/draft-07/schema#"
  }
  ```
</CodeGroup>

<McpToolCall
  tool="veryfront__create_project_inference_policy_standard_tier_opt_in"
  requiresConfirmation={true}
  initialArguments={{
"confirm": false
}}
/>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.