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

# SCX.ai

> Add and configure SCX.ai models in TrueFoundry's AI Gateway using Custom Endpoints.

[SCX.ai](https://scx.ai) provides an **OpenAI-compatible** chat completions API for open-source models. Use **Custom Endpoints** in the AI Gateway to register SCX.ai once, keep the SCX.ai API key on the AI Gateway, and let your applications call models through a single TrueFoundry API key with access control and tracing.

### Prerequisites

**1. Create an SCX.ai account**

Sign up at [platform.scx.ai](https://platform.scx.ai) if you do not already have an account.

**2. Generate an SCX.ai API key**

In the SCX.ai platform, create an API key.

Store the key securely. You will paste it into the AI Gateway's **Custom Headers** configuration — not in client application code.

**3. Get your TrueFoundry API key and gateway URL**

You need a **TrueFoundry API key** (`TFY_API_KEY`) and your **gateway base URL** to call models through the AI Gateway. See [Gateway base URL](https://www.truefoundry.com/docs/ai-gateway/quick-start.md#gateway-base-url) and [Authentication](https://www.truefoundry.com/docs/ai-gateway/authentication.md).

### Adding models

Add SCX.ai to the AI Gateway using **Custom Endpoints**.

**1. Create a Custom Endpoint model account**

In the TrueFoundry dashboard, go to **AI Gateway** → **Models** → **Custom Endpoints** and click **Add Custom Endpoint**.

In **Configure Account**, set:

* **Name** (Account Name): any unique label for this provider (for example, `scx`) — this is your **model account name** and appears as the first path segment in every request URL (`{providerAccountName}`)
* **Endpoint Type**: `None`
* **Header Auth**: keep **disabled**

**2. Add an SCX.ai endpoint**

On the **Endpoints** step, add an integration and configure:

* **Display Name**: any unique label for this endpoint (for example, `inference`) — this is your **custom endpoint display name** and appears as the second path segment in every request URL (`{endpointName}`)
* **Base URL**: `https://api.scx.ai`

Enable **Custom Headers** and add:

* `Authorization`: `Bearer <SCX_API_KEY>`

Keep **Header Auth** and **TLS Settings** disabled unless your deployment requires them.

![Custom Endpoint form for SCX.ai with Display Name inference, Base URL https://api.scx.ai, and an Authorization custom header](https://mintcdn.com/truefoundry/55NDNB4SRggYg0jZ/images/scx-ai-endpoint.png?fit=max\&auto=format\&n=55NDNB4SRggYg0jZ\&q=85\&s=b7c4bed50b1e140d3bf73076f56fc92c)

Endpoint settings — Base URL and upstream headers

> [!NOTE]
>
> The **Authorization** header here is sent **from the AI Gateway to SCX.ai**. Your application should only send the **TrueFoundry API key** to the AI Gateway.

> [!TIP]
>
> You can click **+ Add Custom Endpoint** to register **multiple endpoints** under the same account (for example, `inference`, `vision`, or `fast-inference`). Each gets its own **Display Name** in the URL, but they can all point to the same SCX.ai **Base URL** and headers. Which SCX.ai model runs is chosen in the request body `model` field — not by the display name.

**3. Set access control and save**

On the **Access Control** step, choose who can manage and use this model account, then **Save**.

* **Manager**: users/teams who can edit or delete the custom endpoint
* **User**: users/teams who can call the endpoint (for example, `everyone`)

### Inference

Once saved, call SCX.ai through the AI Gateway's **proxy-api** path. URL shape and path rules are documented under [Custom Endpoints](https://www.truefoundry.com/docs/ai-gateway/custom-endpoints#endpoint-structure).

#### How the request URL is built

The AI Gateway URL has two values **you configure in the dashboard** — they are not SCX.ai model IDs:

| URL segment | Dashboard field | Example in this guide |
| - | - | - |
| `{providerAccountName}` | **Account Name** (Configure Account → **Name**) | `scx` |
| `{endpointName}` | **Custom endpoint Display Name** (Endpoints step) | `inference` |

Full URL pattern:

```text theme={"dark"}
{GATEWAY_BASE_URL}/proxy-api/{providerAccountName}/{endpointName}/v1/chat/completions
```

With the example configuration above:

```text theme={"dark"}
{GATEWAY_BASE_URL}/proxy-api/scx/inference/v1/chat/completions
```

| Segment | Example value | Meaning |
| - | - | - |
| `{GATEWAY_BASE_URL}` | `https://internal.devtest.truefoundry.tech/api/llm` | Your AI Gateway base URL |
| `scx` | Account Name you set in **Configure Account** | `{providerAccountName}` |
| `inference` | Display Name you set for the custom endpoint | `{endpointName}` |
| `v1/chat/completions` | Upstream path | Appended to the integration **Base URL** |

The AI Gateway forwards the request to:

```text theme={"dark"}
https://api.scx.ai/v1/chat/completions
```

#### Choosing an SCX.ai model

SCX.ai hosts **many models**. You do **not** need a separate custom endpoint per model — set the `model` field in the JSON request body to whichever SCX.ai model ID you want to run (for example, `Meta-Llama-3.3-70B-Instruct`).

If you add multiple custom endpoints under the same account (different **Display Name** values), use the matching `{endpointName}` in the URL; each endpoint can still call any SCX.ai model via the request body.

> [!NOTE]
>
> Replace `scx` and `inference` in the URL with your own **Account Name** and **Display Name** if you used different values during setup.

### Supported APIs

| API | Endpoint | Tracing | Cost Tracking |
| - | - | - | - |
| [Chat Completions](#chat-completions) | `/proxy-api/{providerAccountName}/{endpointName}/v1/chat/completions` | **✅** | |

> [accordion] Chat Completions
>
> **Before you start:** Replace `{GATEWAY_BASE_URL}` with your gateway base URL ([how to find it](https://www.truefoundry.com/docs/ai-gateway/quick-start.md#gateway-base-url)) and set `TFY_API_KEY` to your TrueFoundry API key.
>
> #### Request headers (client → gateway)
>
> | Header | Value |
> | - | - |
> | `Authorization` | `Bearer <TFY_API_KEY>` |
> | `Content-Type` | `application/json` |
> | `Accept-Encoding` | `identity` |
>
> #### Python (`requests`)
>
> ```python lines theme={"dark"}
> import os
>
> import requests
>
> GATEWAY_BASE_URL = "{GATEWAY_BASE_URL}"  # e.g. https://internal.devtest.truefoundry.tech/api/llm
> TFY_API_KEY = os.environ.get("TFY_API_KEY", "your-tfy-api-key")
>
> # providerAccountName = Account Name from Configure Account (e.g. scx)
> # endpointName = Custom endpoint Display Name (e.g. inference)
> # model in BODY = SCX.ai model ID (e.g. Meta-Llama-3.3-70B-Instruct)
> PROVIDER_ACCOUNT_NAME = "scx"
> ENDPOINT_NAME = "inference"
> URL = f"{GATEWAY_BASE_URL}/proxy-api/{PROVIDER_ACCOUNT_NAME}/{ENDPOINT_NAME}/v1/chat/completions"
>
> HEADERS = {
>     "Authorization": f"Bearer {TFY_API_KEY}",
>     "Content-Type": "application/json",
>     "Accept-Encoding": "identity",
> }
>
> BODY = {
>     "model": "Meta-Llama-3.3-70B-Instruct",  # any SCX.ai model ID
>     "messages": [
>         {"role": "system", "content": "You are a helpful assistant."},
>         {"role": "user", "content": "Tell me about TrueFoundry AI Gateway"},
>     ],
>     "temperature": 0.7,
>     "stream": False,
> }
>
> response = requests.post(URL, headers=HEADERS, json=BODY, timeout=120)
> response.raise_for_status()
>
> print(response.json())
> ```
>
> #### cURL
>
> ```bash theme={"dark"}
> curl -X POST "{GATEWAY_BASE_URL}/proxy-api/scx/inference/v1/chat/completions" \
>   -H "Authorization: Bearer $TFY_API_KEY" \
>   -H "Content-Type: application/json" \
>   -H "Accept-Encoding: identity" \
>   -d '{
>     "model": "Meta-Llama-3.3-70B-Instruct",
>     "messages": [
>       {"role": "system", "content": "You are a helpful assistant."},
>       {"role": "user", "content": "Tell me about TrueFoundry AI Gateway"}
>     ],
>     "temperature": 0.7,
>     "stream": false
>   }'
> ```
>
> #### OpenAI Python SDK
>
> Because SCX.ai is OpenAI-compatible, you can point the OpenAI SDK at the AI Gateway proxy path instead of SCX.ai directly:
>
> ```python lines theme={"dark"}
> import os
>
> from openai import OpenAI
>
> GATEWAY_BASE_URL = "{GATEWAY_BASE_URL}"  # e.g. https://internal.devtest.truefoundry.tech/api/llm
> TFY_API_KEY = os.environ.get("TFY_API_KEY", "your-tfy-api-key")
>
> PROVIDER_ACCOUNT_NAME = "scx"  # Account Name
> ENDPOINT_NAME = "inference"    # Custom endpoint Display Name
>
> client = OpenAI(
>     api_key=TFY_API_KEY,
>     base_url=f"{GATEWAY_BASE_URL}/proxy-api/{PROVIDER_ACCOUNT_NAME}/{ENDPOINT_NAME}/v1",
> )
>
> response = client.chat.completions.create(
>     model="Meta-Llama-3.3-70B-Instruct",  # any SCX.ai model ID
>     messages=[
>         {"role": "system", "content": "You are a helpful assistant."},
>         {"role": "user", "content": "Tell me about TrueFoundry AI Gateway"},
>     ],
>     temperature=0.7,
>     stream=False,
> )
>
> print(response.choices[0].message.content)
> ```
>
> > [!NOTE]
> >
> > **Support scope:** Custom Endpoints proxy requests transparently to SCX.ai. For gateway limitations on Custom Endpoints (HTTPS, streaming, and so on), see [Custom Endpoints](https://www.truefoundry.com/docs/ai-gateway/custom-endpoints).


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