Skip to main content

Run DIAL with the echo application

In this tutorial, you will run a complete DIAL stack locally with Docker Compose and chat with a sample echo application that mirrors every prompt you send. By the end, you will have DIAL Chat open at http://localhost:3000 with a working application registered in DIAL Core. This is the simplest way to verify a DIAL deployment. No cloud account or model API key is required.

Prerequisites​

  • Docker Engine with Docker Compose v2.20.0 or higher. See the Docker documentation.
  • Free TCP ports 3000 (DIAL Chat) and 8080 (DIAL Core) on your machine.

What you'll build​

A local DIAL stack — DIAL Core, DIAL Chat, Redis, and chat themes — running the echo application, a small service that repeats whatever you type. The echo application is the canonical "hello world" for the platform: it exercises the full request path from Chat through DIAL Core to a registered application, without depending on any model.

Project structure​

The dial-docker-compose/application directory you download looks like this:

application/
├── docker-compose.yml
├── core/
│   └── config.json
└── echo/
    ├── app.py
    ├── Dockerfile
    └── requirements.txt

The docker-compose.yml includes the shared common.yml base and adds the locally built echo service:

include:
  - path: ../common.yml
    env_file: ./.env

services:
  echo:
    build: echo

Step 1: Get the Docker Compose files​

Download the dial-docker-compose/application directory from the DIAL repository, or clone the repository and change into it:

git clone https://github.com/epam/ai-dial.git
cd ai-dial/dial-docker-compose/application

Verify: the directory contains docker-compose.yml, a core/ directory, and an echo/ directory.

Step 2: Launch DIAL​

From the application directory, start the stack:

docker compose up

Docker pulls the DIAL Core, DIAL Chat, themes, and Redis images, then builds and starts the echo application. The first run takes a few minutes while images download.

Verify: the logs show the core, chat, and echo services started, with no errors.

Step 3: Open DIAL Chat​

Open http://localhost:3000 in your browser.

Verify: the DIAL Chat interface loads, and the Catalog is reachable from the left sidebar.

Step 4: Chat with the echo application​

  1. Open the Catalog from the sidebar.
  2. Select My Echo App.
  3. Type a prompt and send it.

Verify: the echo application returns your message unchanged. You now have a working DIAL deployment.

How it fits together​

DIAL Core reads its configuration from the config.json mounted at core/config.json. The echo application is registered there as an application that DIAL Core exposes through the Unified API:

"echo": {
    "displayName": "My Echo App",
    "description": "Simple application that repeats user's message",
    "endpoint": "http://echo:5000/openai/deployments/echo/chat/completions"
}

A default role grants access to the application, and an API key maps to that role:

"keys": {
    "dial_api_key": {
        "project": "TEST-PROJECT",
        "role": "default"
    }
},
"roles": {
    "default": {
        "limits": {
            "echo": {}
        }
    }
}

Every model and application in DIAL is registered the same way and reached through the same Unified API. That uniformity is what lets any app call any model — or any other app — without custom integration.

What you learned​

  • How to run a complete DIAL stack locally with Docker Compose
  • How to open DIAL Chat and select an application from the Catalog
  • How DIAL Core registers an application, a role, and an API key in config.json

Further reading​