DIAL Core

DIAL Core is the API gateway at the center of DIAL and the only service every deployment must run. Clients, DIAL Chat, and applications reach models, applications, toolsets, and stored resources only through its APIs. This page is for platform engineers who deploy and configure Core; it summarizes what Core does, what it needs, and where each part is configured.

info

• Repository
• Releases
• Docker Hub image tags

What DIAL Core does

Core is headless: it has no user interface of its own. It is written in Java 21 on Eclipse Vert.x.

Responsibility	What Core does	Where you configure it
AI APIs	Serves OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, and OpenAI Embeddings for the deployments that support them. The Unified API extends Chat Completions and Embeddings.	Models, Applications, Translators
Load balancing and failover	Spreads requests over a model's upstreams by tier and weight, and retries another upstream on a retriable error.	Load balancing and upstreams
Access control	Authenticates API keys and identity-provider tokens, and checks roles on every model, application, toolset, route, and stored resource.	Identity providers, Access, Roles, Keys
Usage and cost limits	Enforces token, request, and cost limits per role, based on model pricing.	Roles, Global settings, Models
Request processing	Runs interceptor chains on requests and responses.	Interceptors
MCP	Registers toolsets, lists their tools, and proxies tool calls to MCP servers.	Toolsets, Toolsets security
Custom APIs	Proxies your own HTTP and WebSocket APIs behind DIAL authentication and access control.	Routes
Resource storage	Stores files, conversations, prompts, applications, toolsets, and skills, with sharing and publication.	Storage, Resources, Encryption
Telemetry	Writes request logs for usage analytics and emits OpenTelemetry spans.	Analytics and tracing, gflog.xml

For how these responsibilities fit with the other DIAL services, see Architecture highlights.

What DIAL Core depends on

Dependency	What Core uses it for
Blob storage	Permanent data: user resources and the configuration written through the Configuration API. Supported providers are AWS S3, Azure Blob Storage, Google Cloud Storage, S3-compatible stores, and the local filesystem.
Redis	Volatile data kept in memory for fast access: cached resources, pending resource writes, per-request API keys, per-trace usage records, and coordination between Core instances.
Identity provider	Sign-in for users. At least one identity provider must be configured.

Core needs no relational database. Storage permissions and sizing are in Storage and Redis.

How DIAL Core is configured

Core takes two kinds of configuration:

• Static settings are read once at startup, from a JSON file and environment variables. They cover the server, storage, Redis, identity providers, and other runtime behavior. A change needs a restart.
• Dynamic configuration defines what Core serves: models, applications, interceptors, routes, roles, keys, and other entities. Core reads it from JSON files and from the platform bucket in blob storage, and applies changes while it runs.

See How DIAL Core is configured for how the two sources are merged and reloaded.

Ports and interfaces

Interface	Default	Configured by
HTTP API	Port 8080	server.port in Server and client
Prometheus metrics	Port 9464, embedded server	vertx.metricsOptions in Server and client

Every endpoint is described in the DIAL Core API reference. Core generates its OpenAPI specification from the source code; endpoints still under development are marked x-preview: true and can change without backward compatibility.

Deployment

• Kubernetes: deploy Core with the umbrella dial Helm chart, which also deploys other DIAL services, or with the dial-core chart alone. See Core chart configuration and Cloud deployment.
• Docker Compose: to try Core on your own machine, run ai-dial-samples — DIAL in Docker with small open-source models, so you need no API keys and no cloud account. The simple setup runs DIAL Chat, DIAL Core, and Quick Apps; the advanced setup adds DIAL Admin, evaluations, analytics, a sample agent and interceptor, and role-based access. To build your own Docker Compose setup, see Local setup.

In both cases, provide the static settings and the dynamic configuration described in Configuration.