mirror of
https://github.com/tiennm99/DocsGPT.git
synced 2026-10-03 11:11:58 +00:00
Alex
aecb596e99
Backend (arc53/docsgpt): 4.5 GB compressed -> 0.9 GB with both embedding models and tiktoken baked in. - torch/transformers gone from the default install (docling extra only). - Ubuntu 24.04 ships python3.12: no deadsnakes PPA, no software-properties- common; every pin is a wheel, so no gcc/g++/rust in the builder. - COPY --chown and a prefetch that runs as the process user replace the trailing chown -R, which duplicated the 600 MB model layer. - .dockerignore keeps __pycache__, .coverage, local indexes and .env out. - EXTRAS build arg (INSTALL_DOCLING kept as an alias); the docling variant also bakes docling's layout/table/RapidOCR models (DOCLING_ARTIFACTS_PATH) and tesseract, and drops only the discovery documents of Google APIs the app never builds. - FLASK_DEBUG env removed (unused); OCI labels added. Frontend (arc53/docsgpt-fe): 302 MB Vite dev server -> 25 MB static build behind nginx. VITE_* variables are injected at container start into /config.js and read through src/env.ts, so the image no longer needs a rebuild per deployment; docker-compose.yaml keeps hot reload via the dev target. Publishing: every release and develop build now pushes a slim tag and a -docling tag (docling engine + models + tesseract). docker-compose-hub.yaml takes DOCSGPT_IMAGE_TAG / DOCSGPT_IMAGE_VARIANT; docker-compose-standalone.yaml runs the stack from pre-built images without a checkout and is attached to each release. setup.sh selects the -docling variant for OCR instead of requiring a local build. A new workflow builds the image on PRs that touch it and runs verify_offline under --network none; lint checks the exported requirements match uv.lock.
186 lines
8.6 KiB
Plaintext
186 lines
8.6 KiB
Plaintext
---
|
|
title: Docker Deployment of DocsGPT
|
|
description: Deploy DocsGPT using Docker and Docker Compose for easy setup and management.
|
|
---
|
|
|
|
# Docker Deployment of DocsGPT
|
|
|
|
Docker is the recommended method for deploying DocsGPT, providing a consistent and isolated environment for the application to run. This guide will walk you through deploying DocsGPT using Docker and Docker Compose.
|
|
|
|
## Prerequisites
|
|
|
|
* **Docker Engine:** You need to have Docker Engine installed on your system.
|
|
* **macOS:** [Docker Desktop for Mac](https://docs.docker.com/desktop/install/mac-install/)
|
|
* **Linux:** [Docker Engine Installation Guide](https://docs.docker.com/engine/install/) (follow instructions for your specific distribution)
|
|
* **Windows:** [Docker Desktop for Windows](https://docs.docker.com/desktop/install/windows-install/) (requires WSL 2 backend, see notes below)
|
|
* **Docker Compose:** Docker Compose is usually included with Docker Desktop. If you are using Docker Engine separately, ensure you have Docker Compose V2 installed.
|
|
|
|
**Important Note for Windows Users:** Docker Desktop on Windows generally requires the WSL 2 backend to function correctly, especially when using features like host networking which are utilized in DocsGPT's Docker Compose setup. Ensure WSL 2 is enabled and configured in Docker Desktop settings.
|
|
|
|
## Quickest Setup: Pre-built Images, No Checkout
|
|
|
|
Every release publishes ready-to-run images to Docker Hub (`arc53/docsgpt`,
|
|
`arc53/docsgpt-fe`) and GitHub Container Registry (`ghcr.io/arc53/docsgpt`,
|
|
`ghcr.io/arc53/docsgpt-fe`) for `linux/amd64` and `linux/arm64`. The images
|
|
contain everything the default configuration needs (embedding models,
|
|
tokenizers, tiktoken's encoding), so a fresh container makes no downloads on
|
|
first use. You do not need the source tree to run them:
|
|
|
|
1. **Download the standalone Compose file** (also attached to every
|
|
[release](https://github.com/arc53/DocsGPT/releases)):
|
|
|
|
```bash
|
|
mkdir docsgpt && cd docsgpt
|
|
curl -fsSLO https://raw.githubusercontent.com/arc53/DocsGPT/main/deployment/docker-compose-standalone.yaml
|
|
```
|
|
|
|
2. **Create a `.env` next to it** with your settings, for example the public API:
|
|
|
|
```
|
|
LLM_PROVIDER=docsgpt
|
|
VITE_API_STREAMING=true
|
|
```
|
|
|
|
3. **Start it:**
|
|
|
|
```bash
|
|
docker compose -f docker-compose-standalone.yaml up -d
|
|
```
|
|
|
|
Then open [http://localhost:5173/](http://localhost:5173/). Data lives in
|
|
named Docker volumes; `docker compose -f docker-compose-standalone.yaml down`
|
|
keeps it and `down -v` removes it.
|
|
|
|
**Tags and variants.** `DOCSGPT_IMAGE_TAG` picks the version: a release such
|
|
as `0.20.0`, `latest` (the newest release, the default) or `develop` (follows
|
|
the `main` branch). `DOCSGPT_IMAGE_VARIANT` picks the flavour: empty for the
|
|
slim default image, or `-docling` for the image with the docling parser
|
|
engine, its models and tesseract baked in (needed for OCR of scanned
|
|
documents, see the [OCR guide](/Guides/ocr)). Both are read from `.env` or
|
|
the shell, e.g. `DOCSGPT_IMAGE_TAG=0.20.0 DOCSGPT_IMAGE_VARIANT=-docling`.
|
|
The same two variables drive `deployment/docker-compose-hub.yaml` in a
|
|
checkout.
|
|
|
|
## Using the Source Checkout
|
|
|
|
With a clone of the repository, `deployment/docker-compose-hub.yaml` runs the
|
|
same pre-built images while keeping your data in `application/indexes`,
|
|
`application/inputs` and `application/vectors`, and `deployment/docker-compose.yaml`
|
|
builds the images from your working tree (for local changes, or a build with
|
|
extra packages: `EXTRAS=docling` in `.env`).
|
|
|
|
1. **Clone the DocsGPT Repository (if you haven't already):**
|
|
|
|
```bash
|
|
git clone https://github.com/arc53/DocsGPT.git
|
|
cd DocsGPT
|
|
```
|
|
|
|
2. **Create a `.env` file:**
|
|
|
|
In the root directory of your DocsGPT repository, create a file named `.env`.
|
|
|
|
3. **Add Public API Configuration to `.env`:**
|
|
|
|
Open the `.env` file and add the following lines:
|
|
|
|
```
|
|
LLM_PROVIDER=docsgpt
|
|
VITE_API_STREAMING=true
|
|
```
|
|
|
|
This minimal configuration tells DocsGPT to use the public API. For more advanced settings and other LLM options, refer to the [DocsGPT Settings Guide](/Deploying/DocsGPT-Settings).
|
|
|
|
4. **Launch DocsGPT with Docker Compose:**
|
|
|
|
Navigate to the root directory of the DocsGPT repository in your terminal and run:
|
|
|
|
```bash
|
|
docker compose --env-file .env -f deployment/docker-compose-hub.yaml up -d
|
|
```
|
|
|
|
The `-d` flag runs Docker Compose in detached mode (in the background).
|
|
To build the images from your working tree instead of pulling them, use
|
|
`deployment/docker-compose.yaml` with `up --build -d`.
|
|
|
|
5. **Access DocsGPT in your browser:**
|
|
|
|
Once the containers are running, open your web browser and go to [http://localhost:5173/](http://localhost:5173/).
|
|
|
|
6. **Stopping DocsGPT:**
|
|
|
|
To stop the application, navigate to the same directory in your terminal and run:
|
|
|
|
```bash
|
|
docker compose -f deployment/docker-compose-hub.yaml down
|
|
```
|
|
|
|
## Optional Ollama Setup (Local Models)
|
|
|
|
DocsGPT provides optional Docker Compose files to easily integrate with [Ollama](https://ollama.com/) for running local models. These files add an official Ollama container to your Docker Compose setup. These files are located in the `deployment/optional/` directory.
|
|
|
|
There are two Ollama optional files:
|
|
|
|
* **`docker-compose.optional.ollama-cpu.yaml`**: For running Ollama on CPU.
|
|
* **`docker-compose.optional.ollama-gpu.yaml`**: For running Ollama on GPU (requires Docker to be configured for GPU usage).
|
|
|
|
### Launching with Ollama and Pulling a Model
|
|
|
|
1. **Clone the DocsGPT Repository and Create `.env` (as described above).**
|
|
|
|
2. **Launch DocsGPT with Ollama Docker Compose:**
|
|
|
|
Choose the appropriate Ollama Compose file (CPU or GPU) and launch DocsGPT:
|
|
|
|
**CPU:**
|
|
```bash
|
|
docker compose --env-file .env -f deployment/docker-compose-hub.yaml -f deployment/optional/docker-compose.optional.ollama-cpu.yaml up -d
|
|
```
|
|
**GPU:**
|
|
```bash
|
|
docker compose --env-file .env -f deployment/docker-compose-hub.yaml -f deployment/optional/docker-compose.optional.ollama-gpu.yaml up -d
|
|
```
|
|
|
|
3. **Pull the Ollama Model:**
|
|
|
|
**Crucially, after launching with Ollama, you need to pull the desired model into the Ollama container.** Find the `LLM_NAME` you configured in your `.env` file (e.g., `llama3.2:1b`). Then execute the following command to pull the model *inside* the running Ollama container:
|
|
|
|
```bash
|
|
docker compose -f deployment/docker-compose-hub.yaml -f deployment/optional/docker-compose.optional.ollama-cpu.yaml exec -it ollama ollama pull <LLM_NAME>
|
|
```
|
|
or (for GPU):
|
|
```bash
|
|
docker compose -f deployment/docker-compose-hub.yaml -f deployment/optional/docker-compose.optional.ollama-gpu.yaml exec -it ollama ollama pull <LLM_NAME>
|
|
```
|
|
Replace `<LLM_NAME>` with the actual model name from your `.env` file.
|
|
|
|
4. **Access DocsGPT in your browser:**
|
|
|
|
Once the model is pulled and containers are running, open your web browser and go to [http://localhost:5173/](http://localhost:5173/).
|
|
|
|
5. **Stopping Ollama Setup:**
|
|
|
|
To stop a DocsGPT setup launched with Ollama optional files, use `docker compose down` and include all the compose files used during the `up` command:
|
|
|
|
```bash
|
|
docker compose -f deployment/docker-compose-hub.yaml -f deployment/optional/docker-compose.optional.ollama-cpu.yaml down
|
|
```
|
|
or
|
|
|
|
```bash
|
|
docker compose -f deployment/docker-compose-hub.yaml -f deployment/optional/docker-compose.optional.ollama-gpu.yaml down
|
|
```
|
|
|
|
**Important for GPU Usage:**
|
|
|
|
* **NVIDIA Container Toolkit (for NVIDIA GPUs):** If you are using NVIDIA GPUs, you need to have the [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) installed and configured on your system for Docker to access your GPU.
|
|
* **Docker GPU Configuration:** Ensure Docker is configured to utilize your GPU. Refer to the [Ollama Docker Hub page](https://hub.docker.com/r/ollama/ollama) and Docker documentation for GPU setup instructions specific to your GPU type (NVIDIA, AMD, Intel).
|
|
|
|
## Restarting After Configuration Changes
|
|
|
|
Whenever you modify the `.env` file or any Docker Compose files, you need to restart the Docker containers for the changes to be applied. Use the same `docker compose down` and `docker compose up -d` commands you used to launch DocsGPT, ensuring you include all relevant `-f` flags for optional files if you are using them.
|
|
|
|
## Further Configuration
|
|
|
|
This guide covers the basic Docker deployment of DocsGPT. For detailed information on configuring various aspects of DocsGPT, such as LLM providers, models, vector stores, and more, please refer to the comprehensive [DocsGPT Settings Guide](/Deploying/DocsGPT-Settings).
|