# Transcribe and Prompt Content with AutoShow Docker

> Use the AutoShow Docker image to transcribe audio or video, apply built-in or custom LLM prompts, and save every result on your host.

- **Collection:** Blog post
- **Published:** 2026-09-02
- **Author:** Anthony Campolo
- **Canonical URL:** https://ajcwebdev.com/autoshow-docker-transcription-prompts/
- **Markdown URL:** https://ajcwebdev.com/autoshow-docker-transcription-prompts/index.md
- **JSON URL:** https://ajcwebdev.com/autoshow-docker-transcription-prompts/index.json

---

## Overview

[AutoShow](https://github.com/ajcwebdev/autoshow-cli) can turn an audio file, video file, or supported media URL into a timestamped transcript, then pass that transcript to a hosted large language model to produce summaries, takeaways, chapters, social posts, or another structured text result. Its published Docker image packages the CLI, FFmpeg, `ffprobe`, `yt-dlp`, Tesseract, MuPDF, qpdf, and Calibre, so Bun and those media tools do not need to be installed on the host.

This guide creates two explicit output directories:

```txt wrap=false
output/
├── interview-transcript/
│   ├── transcription.txt
│   └── result.json
└── interview-notes/
    ├── text.json
    └── text.md
```

This guide uses AssemblyAI Universal-3.5 Pro for transcription and OpenAI for text generation. AutoShow also supports [additional STT providers](https://github.com/ajcwebdev/autoshow-cli/blob/main/docs/commands/process-steps/step-2-extract/02-extract-stt.md) and [additional LLM providers](https://github.com/ajcwebdev/autoshow-cli/blob/main/docs/commands/process-steps/step-3-write/write-text.md).

## Pull the AutoShow Docker image

Docker Desktop or Docker Engine is the only local runtime required. Pull the latest multi-architecture image from GitHub Container Registry and save its name in a shell variable:

```bash wrap=false
export AUTOSHOW_IMAGE=ghcr.io/ajcwebdev/autoshow-cli:latest
docker pull "$AUTOSHOW_IMAGE"
docker run --rm "$AUTOSHOW_IMAGE" --version
```

The `latest` tag is convenient for interactive use. For a repeatable automation or production workflow, replace it with a full commit SHA tag.

To build the image from a local AutoShow checkout instead:

```bash wrap=false
docker build -t autoshow-cli:local .
export AUTOSHOW_IMAGE=autoshow-cli:local
```

## Create a host workspace

Create directories for source media, custom prompts, and generated artifacts:

```bash wrap=false
mkdir -p autoshow-work/input autoshow-work/output autoshow-work/prompts
cd autoshow-work
```

Copy a media file to `input/`. The examples below use `input/interview.mp4`, but audio formats such as MP3 and WAV work too.

Create a host-side `.env` file containing the credentials for the selected providers:

```dotenv wrap=false
ASSEMBLYAI_API_KEY=replace-with-your-assemblyai-key
OPENAI_API_KEY=replace-with-your-openai-key
```

Add `.env` and `output/` to the workspace's `.gitignore`. AutoShow's container entrypoint deliberately disables automatic `.env` loading, so every provider-backed command below uses Docker's `--env-file .env` option. Docker exports those values into the container without mounting the credential file.

Each command bind-mounts the current host directory at `/workspace` and makes it the container's working directory. As a result, `input/interview.mp4` is readable inside the container and everything written below `output/` persists on the host after the temporary container exits.

## Transcribe audio or video

First, estimate the transcription cost without calling the STT provider:

```bash wrap=false
docker run --rm -i \
  --env-file .env \
  --mount "type=bind,src=$(pwd),dst=/workspace" \
  --workdir /workspace \
  "$AUTOSHOW_IMAGE" extract input/interview.mp4 \
  --provider assemblyai=universal-3-5-pro \
  --price
```

Remove `--price` and pin the output directory when the estimate looks acceptable:

```bash wrap=false
docker run --rm -i \
  --env-file .env \
  --mount "type=bind,src=$(pwd),dst=/workspace" \
  --workdir /workspace \
  "$AUTOSHOW_IMAGE" extract input/interview.mp4 \
  --provider assemblyai=universal-3-5-pro \
  --output-dir output/interview-transcript
```

A successful single-provider run writes the readable transcript to `output/interview-transcript/transcription.txt` and the structured provider result to `output/interview-transcript/result.json`. AssemblyAI Universal-3.5 Pro supports speaker diarization; add `--speaker-count 2` when you know how many people are speaking. Add `--split` for long media when you want AutoShow to process it in 30-minute segments.

The input can also be a supported public media URL. AutoShow uses the bundled `yt-dlp` and FFmpeg tools to download and prepare its audio:

```bash wrap=false
docker run --rm -i \
  --env-file .env \
  --mount "type=bind,src=$(pwd),dst=/workspace" \
  --workdir /workspace \
  "$AUTOSHOW_IMAGE" extract "https://www.youtube.com/watch?v=VIDEO_ID" \
  --youtube-captions \
  --provider assemblyai=universal-3-5-pro \
  --output-dir output/youtube-transcript
```

`--youtube-captions` prefers existing English captions and falls back to the selected STT provider when captions are unavailable.

## Run built-in prompts on the transcript

AutoShow's `write` command accepts a local Markdown or plaintext file. It does not accept media or a URL directly, which is why transcription and writing are separate commands.

Estimate the LLM request before running it:

```bash wrap=false
docker run --rm -i \
  --env-file .env \
  --mount "type=bind,src=$(pwd),dst=/workspace" \
  --workdir /workspace \
  "$AUTOSHOW_IMAGE" write output/interview-transcript/transcription.txt \
  --llm openai \
  --prompt shortSummary takeaways \
  --price
```

Then generate a short summary and key takeaways as both structured JSON and rendered Markdown:

```bash wrap=false
docker run --rm -i \
  --env-file .env \
  --mount "type=bind,src=$(pwd),dst=/workspace" \
  --workdir /workspace \
  "$AUTOSHOW_IMAGE" write output/interview-transcript/transcription.txt \
  --llm openai \
  --prompt shortSummary takeaways \
  --rendered-text \
  --output-dir output/interview-notes
```

The structured response is saved to `output/interview-notes/text.json`; `--rendered-text` also creates `output/interview-notes/text.md`. Omitting the model from `--llm openai` selects AutoShow's current default OpenAI model. Specify an exact `provider=model` pair when reproducibility matters.

Useful built-in prompt names include:

| Goal | Prompt names |
| --- | --- |
| Summarize | `shortSummary`, `longSummary`, `bulletPoints`, `takeaways` |
| Organize | `chapterTitles`, `shortChapters`, `mediumChapters`, `longChapters` |
| Publish | `blog`, `seoArticle`, `emailNewsletter`, `youtubeDescription` |
| Extract details | `quotes`, `keyMoments`, `faq`, `questions`, `metadata` |

Pass multiple names after one `--prompt` flag, as in the example, to combine compatible outputs in one request.

## Add a custom text prompt

Use `--prompt-file` to prepend your own instructions to a built-in structured prompt. For example, save this as `prompts/action-items.md` on the host:

```md wrap=false
Focus only on commitments, decisions, owners, and deadlines stated in the source. Do not invent an owner or due date. Make uncertainty explicit.
```

Run the custom instructions with the `takeaways` output shape:

```bash wrap=false
docker run --rm -i \
  --env-file .env \
  --mount "type=bind,src=$(pwd),dst=/workspace" \
  --workdir /workspace \
  "$AUTOSHOW_IMAGE" write output/interview-transcript/transcription.txt \
  --llm openai \
  --prompt-file prompts/action-items.md \
  --prompt takeaways \
  --rendered-text \
  --output-dir output/interview-actions
```

The prompt file changes the task instructions while the named preset supplies the validated output structure. This combination is more reliable than asking for an arbitrary response format in prose.

You can also skip transcription and run a prompt directly against any existing `.md` or `.txt` file inside the mounted workspace:

```bash wrap=false
docker run --rm -i \
  --env-file .env \
  --mount "type=bind,src=$(pwd),dst=/workspace" \
  --workdir /workspace \
  "$AUTOSHOW_IMAGE" write input/research-notes.md \
  --llm openai \
  --prompt longSummary \
  --rendered-text \
  --output-dir output/research-summary
```

## Choose mounts and credentials carefully

Only paths mounted into the container are visible to AutoShow. Pass container-relative paths such as `input/interview.mp4`, not an unmounted host-absolute path. If input and output live in different locations, mount each one separately as documented in the project's [Docker guide](https://github.com/ajcwebdev/autoshow-cli/blob/main/docs/docker.md).

On Linux, add `--user "$(id -u):$(id -g)"` before the image name if files written through the bind mount should belong to the current host user.

Hosted processing also changes the privacy boundary. The selected STT provider receives the media needed for transcription, and the selected LLM provider receives the extracted text needed for writing. Do not process private or regulated content until the providers' retention and data-use policies meet your requirements.

## Troubleshooting

- **The CLI cannot find the input:** Confirm the source is below the mounted host directory and that `--workdir /workspace` is present.
- **The CLI reports a missing API key:** Confirm `.env` uses the variable required by the selected provider and that the command includes `--env-file .env` before the image name.
- **`setup --doctor` prints warnings:** Warnings for unused providers and optional tools are expected when they are not part of this AssemblyAI and OpenAI workflow.
- **The output directory is empty on the host:** Confirm the output path is inside `/workspace` or another writable bind mount. Container-only files disappear with `docker run --rm`.

For a deeper look at the same media-to-transcript-to-LLM pipeline, see [Generate Show Notes with Whisper.cpp, Llama.cpp, and Node.js](/autogen-shownotes/) and the [AutoShow CLI walkthrough with Nick Taylor](/videos/autoshow-cli-nick-taylor/).