Applications

An application is a deployment that runs your own logic behind DIAL Core: an agent, a RAG pipeline, or any service that implements the Unified API. Core routes requests to it like a model and applies the same access control, interceptors, and limits. An application can also expose an MCP interface and its own routes. This reference covers registering applications in Core's configuration; it is for platform engineers and application developers who know how DIAL Core is configured.

To build an application, see DIAL Apps. To register one step by step, see Register an app.

Where applications are defined

Source	Location
Config file	`applications.<name>`
Configuration API	`/v1/applications/platform/<name>`

Applications that users create or publish live in their own or the public bucket, and are managed through the resource API, not the configuration. An application's name is a deployment ID, shared with models, toolsets, and interceptors. DIAL Admin manages applications in Applications.

Fields

Field	Description
`endpoint`	The application's Chat Completions URL, used as is.
`baseUrl`	The root URL for every `interfaces` entry that declares no `base_url`.
`interfaces`	The AI APIs the application serves. See Interfaces.
`applicationTypeSchemaId`	The ID of the application type schema the application is based on.
`applicationProperties`	The properties of a schema-rich application. They must conform to the schema named by `applicationTypeSchemaId`.
`displayName`	The name shown in DIAL clients, tables, and logs.
`displayVersion`	The version shown next to the name.
`description`	A short description of the application.
`intro`	A short onboarding text shown to users separately from `description`.
`iconUrl`	The URL of the icon shown for the application.
`descriptionKeywords`	Keywords that describe the application, for example `code-gen`.
`author`	The application's developer.
`createdAt`, `updatedAt`	The dates the application was created and last updated.
`userRoles`	The roles, from identity provider claims or API keys, that may use the application. When unset, every user may use it.
`overrideName`	Rewrites the Chat Completions body's `model` field, and the `X-DIAL-OVERRIDE-NAME` header, to this value before the request reaches the application. It does not change routing.
`forwardAuthToken`	Forwards the caller's `Authorization` header to the application, for pass-through authentication to downstream services.
`dependencies`	The deployments, models and applications, that the application may call. See Authorization for applications.
`inputAttachmentTypes`	The MIME types allowed for input attachments.
`maxInputAttachments`	The maximum number of input attachments. Zero when `inputAttachmentTypes` is unset; otherwise unlimited by default.
`maxRetryAttempts`	How many times Core retries on upstream errors. See Load balancing and upstreams.
`viewerUrl`	The URL of a custom viewer UI that replaces the standard DIAL Chat UI for this application.
`editorUrl`	The URL of a custom builder UI, which lets DIAL Chat users create instances of the application through a wizard.
`interceptors`	Local interceptors for this application, in order. See Interceptors.
`defaults`	Body parameters Core adds to a Chat Completions request that does not carry them.
`defaultHeaders`	Headers Core adds to a request that does not carry them.
`features`	Optional capabilities of the application. See Features.
`mcp`	The application's MCP interface. See MCP.
`routes`	Routes the application exposes. See Application routes.

When applicationTypeSchemaId and applicationProperties are set, parameters defined by the schema take precedence over the same parameters in the application entry. This applies to the fields above, features, and routes.

Interfaces

interfaces works as it does for models. Unlike endpoint, which is used as is, an entry's base URL is joined with the exact path Core received. When interfaces and endpoint both cover Chat Completions, interfaces wins.

Interface	API
`openaiChatCompletions`	Chat Completions. The peer of `endpoint`.
`openaiResponses`	OpenAI Responses API.
`anthropicMessages`	Anthropic Messages.

An interface entry can set base_url, features, defaultHeaders, defaults, and overridePaths, with the same rules as for models:

features overrides application-level features field by field; explicit false and empty arrays override inherited values.
defaultHeaders overrides names it repeats and adds new names, for that interface only.
defaults replaces the application-level defaults for that interface; the two are not merged. A parameter the request carries is never replaced.

An interface declared with no base URL, and not served by endpoint, answers 503.

"applications": {
  "app-via-interfaces": {
    "interfaces": {
      "openaiChatCompletions": { "base_url": "http://my-app:5000" },
      "openaiResponses": { "base_url": "http://my-app:5000" }
    }
  }
}

Default headers

defaultHeaders behave as for models: a header the client sends, or one Core sets itself, wins, and a header Core strips on the way to the application is stripped from the defaults too. With interceptors, the defaults apply on the hop to the first interceptor; an interceptor's own defaultHeaders win on the hop that calls it.

Features

Feature	Default	Description
`rateEndpoint`	—	The URL of a custom rating API. Core exposes it as `<deployment name>/rate`.
`tokenizeEndpoint`	—	The URL of a custom tokenization service. Core exposes it as `<deployment name>/tokenize`.
`truncatePromptEndpoint`	—	The URL of a custom prompt truncation API. Core exposes it as `<deployment name>/truncate_prompt`.
`configurationEndpoint`	—	The URL of a JSON Schema for the application's settings. Core exposes it as `GET /v1/deployments/<deployment name>/configuration`; clients send matching values in `custom_fields.configuration`.
`systemPromptSupported`	`true`	Whether the application accepts a system message.
`toolsSupported`	`false`	Whether the application accepts `tools`.
`seedSupported`	`false`	Whether the application accepts `seed`.
`urlAttachmentsSupported`	`false`	Whether the application accepts URLs as attachments.
`folderAttachmentsSupported`	`false`	Whether the application accepts folders as attachments.
`accessibleByPerRequestKey`	`true`	Whether the application can be called with a per-request API key.
`contentPartsSupported`	`false`	Whether the application accepts requests with content parts.
`consentRequired`	—	Whether users must give consent before they use the application.
`supportCommentInRateResponse`	—	Whether the application accepts a `comment` in the rate payload.
`reasoningEfforts`	`[]`	The `effort` values the application accepts in Chat Completions. An empty list means `effort` is not supported.

For how model and application features differ, see Applications in DIAL Admin.

MCP

mcp exposes the application as an MCP server through Core.

Field	Description
`endpoint`	The application's MCP endpoint.
`transport`	The MCP transport. Default `http`.
`allowedTools`	The tools Core exposes from the server.
`configDelivery`	How Core sends the application's properties to the MCP server: `header` in an HTTP header, or `meta` in the `_meta` field of the MCP message.
`forwardPerRequestKey`	Forwards a per-request API key to the MCP endpoint, so the server can reach files in DIAL storage.

Application routes

An application can expose its own routes, called at /v1/deployments/<application>/route/<path>. Application routes take the same fields as global routes, with these differences:

userRoles is inherited from the application when unset, and overrides it when set.
order sets the priority among the application's own routes.
permissions lists the permissions, READ or WRITE, required to access the route. Default: none.
attachmentPaths.requestBody and attachmentPaths.responseBody are JSON Path lists that tell Core where to find attachment links in the request and response bodies.
authType is ignored. An application route always sends the upstream key as API-KEY, and Authorization depends only on the application's forwardAuthToken.

Example

{
  "applications": {
    "forecast": {
      "endpoint": "http://forecast-app:5000/openai/deployments/forecast/chat/completions",
      "displayName": "Forecast",
      "description": "Forecasts from your sales data",
      "userRoles": ["analyst"],
      "forwardAuthToken": false,
      "inputAttachmentTypes": ["text/csv"],
      "maxInputAttachments": 5,
      "features": { "configurationEndpoint": "http://forecast-app:5000/configuration" },
      "interceptors": ["pii-redaction"],
      "routes": {
        "vector_store_query": {
          "paths": ["/v1/vector_store(/[^/]+)*$"],
          "rewritePath": true,
          "methods": ["GET", "HEAD"],
          "upstreams": [{ "endpoint": "http://vector-store:9876" }],
          "order": 1,
          "permissions": ["WRITE"],
          "attachmentPaths": {
            "requestBody": ["@.attachments[*].url"],
            "responseBody": ["@.result.attachedFiles"]
          }
        }
      }
    }
  }
}

Where applications are defined​

Fields​

Interfaces​

Default headers​

Features​

MCP​

Application routes​

Example​

Further reading​