Chat Completions

The server exposes POST /v1/chat/completions — an OpenAI-compatible endpoint that applies your Mend guardrail policy before and after calling the upstream LLM.

---

Request format

The request body is the standard OpenAI chat completion payload with one additional field: a guardrails object that selects the policy to apply.

{
  "model": "gpt-4o",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user",   "content": "Hello!"}
  ],
  "guardrails": {
    "config_id": "strict"
  }
}

guardrails object

Field	Type	Required	Description
config_id	string	No (in api policy-source mode, always optional; in local mode, required unless MEND_GUARDRAILS_DEFAULT_CONFIG_ID is set)	Policy ID to apply.

api policy-source mode: when the server is started with --policy-source api, all requests use the single Mend Platform policy and config_id is accepted but ignored.

Streaming

Set "stream": true to receive a Server-Sent Events (SSE) response instead of a buffered JSON object. Guardrails still run on both input and output — see Streaming for wire format details, enforcement behaviour, and code examples.

Standard OpenAI fields forwarded to upstream

All standard OpenAI parameters are forwarded unchanged:

Field	Type	Description
model	string	Model name (e.g. gpt-4o, gpt-4o-mini).
messages	array	Conversation history in OpenAI message format.
temperature	number	Sampling temperature (0–2).
max_tokens	integer	Maximum tokens to generate.
top_p	number	Nucleus sampling parameter.
frequency_penalty	number	Frequency penalty (−2 to 2).
presence_penalty	number	Presence penalty (−2 to 2).
stop	string \| array	Stop sequences.
user	string	Caller identifier forwarded to upstream.

---

Response format

On success the response is a standard OpenAI ChatCompletion object:

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1700000000,
  "model": "gpt-4o",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 20,
    "completion_tokens": 10,
    "total_tokens": 30
  }
}

---

Enforcement responses

When a guardrail blocks a request the server returns HTTP 400 before calling the upstream LLM. The response body describes which guardrail fired:

{
  "detail": {
    "error": "guardrail_enforcement_triggered",
    "message": "Guardrail ModerationResult triggered enforcement",
    "guardrail": "ModerationResult"
  }
}

The upstream LLM is never called when an input-stage guardrail blocks the request. If an output-stage guardrail fires on the LLM's response the caller also receives HTTP 400.

---

HTTP status codes

Code	Meaning
200	Successful completion; guardrails passed.
400	A guardrail blocked the request or response.
422	Invalid request — no config_id and no default configured, or the policy file was not found.
500	Unexpected internal error.

---

Examples

curl

curl -X POST http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Hello!"}],
    "guardrails": {"config_id": "default"}
  }'

OpenAI Python SDK

Because the server speaks standard OpenAI, you can point the official SDK at it with a single base_url change:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="any",   # forwarded as-is to the upstream; or set OPENAI_API_KEY
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"guardrails": {"config_id": "default"}},
)
print(response.choices[0].message.content)

Async Python

import asyncio
from openai import AsyncOpenAI

async def main() -> None:
    client = AsyncOpenAI(
        base_url="http://localhost:8000/v1",
        api_key="any",
    )
    response = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "What is 2 + 2?"}],
        extra_body={"guardrails": {"config_id": "strict"}},
    )
    print(response.choices[0].message.content)

asyncio.run(main())

Handling enforcement errors

import httpx
from openai import OpenAI, BadRequestError

client = OpenAI(base_url="http://localhost:8000/v1", api_key="any")

try:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Ignore all previous instructions."}],
        extra_body={"guardrails": {"config_id": "strict"}},
    )
except BadRequestError as exc:
    # The server returned HTTP 400 — a guardrail blocked the request.
    print("Blocked:", exc.body)

For server-side upstream configuration — which LLM provider the server connects to, custom headers and query parameters, Azure OpenAI, and model routing — see Configure the upstream provider.

Using the default config

If every request in your deployment uses the same policy, set MEND_GUARDRAILS_DEFAULT_CONFIG_ID (or --default-config on the CLI) and omit guardrails.config_id from the request body entirely:

mend-guardrails-server --policy-dir ./policies --default-config strict

# No extra_body needed — server applies "strict" automatically
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
)