# DocsGPT: a self-hosted RAG and agent platform you run with Docker

> DocsGPT is an MIT-licensed Python and React platform for document search, assistants and agents, deployed through setup scripts and Docker Compose. It is a strong fit for teams that need ingestion and citations under their own control, and a poor fit for anyone who wants a managed service with no infrastructure to run.

**arc53/DocsGPT** — Private AI platform for agents, assistants and enterprise search. Built-in Agent Builder, Deep research, Document analysis, Multi-model support, and API connectivity for agents.

- Repository: https://github.com/arc53/DocsGPT
- Website: https://app.docsgpt.cloud/
- Stars: 18,271 · Forks: 2,152
- Language: Python
- License: MIT
- Published: 2026-09-09 · Updated: 2026-09-09 · Language: en
- Canonical page: https://hysenlabs.com/projects/arc53-docsgpt

## What DocsGPT actually solves, and for whom

The problem is retrieval over a mixed document estate. A team has PDFs, DOCX and XLSX files, EPUB and Markdown, HTML pages, JSON, PPTX decks, images and audio recordings, and wants answers with citations rather than a chat model that invents things. DocsGPT ingests those formats, indexes them, and returns answers that point back at sources in the UI. The README describes this as "accurate, hallucination-free responses with source citations", which is marketing phrasing, but the mechanism behind it (retrieval-augmented generation over your own corpus) is the real product.

The audience is narrower than the tagline suggests. This is for engineering teams that have a privacy constraint: regulated data, internal documents, or a policy that forbids sending content to a third-party API. The platform supports OpenAI, Google and Anthropic, but also local inference through Ollama and llama_cpp, and the roadmap lists Bring Your Own Model as completed in April 2026. That combination is what makes it viable inside a company that cannot use a hosted document chatbot.

It is not for individuals who want to paste a PDF into a website. The repository ships a Flask backend, a React frontend, Celery workers and a Docker Compose deployment. That is a system to operate, not a utility to open.

## How the ingestion and retrieval pipeline is put together

The repository layout tells most of the story. docsgpt is the backend Flask application and the Python package published to PyPI. frontend is a Vite and React web UI. extensions holds integrations and widgets, including a React chat widget and a Chatwoot integration. deployment holds the Docker Compose file. application and scripts hold supporting code, and tests sits alongside them.

On the backend, the dependency list in pyproject.toml is the clearest evidence of the mechanism. faiss-cpu provides the vector index, beautifulsoup4 and defusedxml handle HTML and XML parsing, docx2txt covers Word files, and fast-ebook handles e-book formats. celery plus celery-redbeat and croniter drive background work and scheduled agents; the roadmap notes agent scheduling is RedBeat-backed. elevenlabs appears in the dependency list, which lines up with the speech workflow feature: record voice into chat, transcribe on the backend, and ingest meeting recordings as searchable knowledge. boto3 suggests S3-compatible object storage. cryptography and alembic point at encrypted secrets and database migrations, and the roadmap records a Postgres migration for user data in April 2026.

The practical consequence is that retrieval quality depends on choices you make, not on a fixed pipeline. Which embedding model you point at, how documents are chunked, and whether you run FAISS locally or delegate to a provider all change results. The README does not document chunking parameters or index tuning, so treat the defaults as a starting point you will have to inspect in the code.

## Installing DocsGPT with Docker and running the first query

The README requires Docker and points at a Quickstart page for detail. The sequence is a clone, a setup script, and a browser. On macOS and Linux the script is setup.sh; on Windows it is setup.ps1 invoked through PowerShell. The scripts write your .env file for you.

Start by cloning and entering the directory:

```bash
git clone https://github.com/arc53/DocsGPT.git
cd DocsGPT
```

Then run the platform-specific setup script. On macOS and Linux:

```bash
./setup.sh
```

On Windows, from PowerShell in the same directory:

```powershell
PowerShell -ExecutionPolicy Bypass -File .\setup.ps1
```

The script presents five options: using the public API, running locally, connecting to a local inference engine, using a cloud API provider, or building the Docker image locally. According to the README, it then configures .env and handles the downloads and installations that your choice requires. Pick the local inference engine option if you want Ollama or llama_cpp and no external calls; pick a cloud provider if you already have keys and want faster setup.

Once the stack is up, open the UI at http://localhost:5173/ and upload a document. The backend parses it, indexes it, and the chat view answers with citations. To stop everything, run the compose file down:

```bash
docker compose -f deployment/docker-compose.yaml down
```

The README also notes that development environment setup is documented separately, so do not assume the setup script gives you a working dev loop with hot reload. For that, follow the Development Environment guide.

## Where DocsGPT gets awkward: operations, upgrades and scope

The first limitation is operational weight. This is a multi-service deployment: Flask backend, React frontend, Celery workers, a scheduler, and a database. The README mentions Kubernetes support for enterprise deployment but does not document a Helm chart or manifests in the repository, so the Kubernetes path is a claim rather than a described procedure. If you do not already run container orchestration, you are adopting one.

The second is upgrade cost. The roadmap records a Postgres migration for user data in April 2026, and alembic is a direct dependency, which means schema migrations are part of the release process. The README does not document rollback. Before upgrading across a release boundary, check the release notes for that version rather than assuming the compose file alone is sufficient. Pinning to a known release and reading the changelog is the safer pattern.

The third is scope creep in the other direction: if all you need is semantic search over a few hundred Markdown files, this platform is more machinery than the problem deserves. A single embedding index behind a small script would be easier to reason about and cheaper to run. DocsGPT earns its complexity when you need multiple connectors, agent workflows, scheduled runs, role-based access and audit trails in one place.

Finally, the README's claim of hallucination-free answers is not something a retrieval system can guarantee. Citations make errors easier to catch; they do not prevent them. Judge the output yourself on your own corpus.

## DocsGPT compared with privateGPT and plain RAG stacks

The most common comparison is privateGPT, which appears in the related searches alongside DocsGPT. Both are self-hosted document question-answering projects with local model support, and both target the privacy-constrained user. The difference in approach is breadth versus focus. privateGPT is oriented around a local question-answering pipeline over your documents. DocsGPT has grown into a platform: an agent workflow builder with conditional nodes, research mode, SharePoint and Confluence connectors, team-scoped sharing with roles, OIDC and SSO login with SCIM provisioning, an admin dashboard with role-based access control, agent import and export, and per-agent analytics. Those are product features, not retrieval features, and they change what you are signing up to maintain.

Against a hand-rolled RAG stack (FAISS or a hosted vector store, an embedding model, a thin API), DocsGPT's advantage is that ingestion, citations, widgets, and access control already exist. Its disadvantage is that you inherit its release cadence and its database migrations. A custom stack has no upgrade path to manage because you wrote it, but you also own every connector and every UI change.

The honest framing: choose DocsGPT if the surrounding product surface is what you lack. Choose a smaller stack if retrieval is the only thing you need.

## Licence, maintenance and what upgrading costs you

DocsGPT is MIT licensed, and pyproject.toml declares license = "MIT" with license-files = ["LICENSE"]. MIT is permissive: you can use it commercially, modify it, and redistribute it, provided the copyright notice and licence text are preserved. That is the extent of what the repository states. It says nothing about trademark use of the DocsGPT name, and nothing about support obligations. If you fork and ship it inside a product, the licence text travels with your distribution; beyond that, get your own legal read rather than treating this paragraph as advice.

The project is not archived. The last push was on 2026-09-09, and releases 0.19.0, 0.18.0 and 0.17.3 landed between June and August 2026, so the release cadence is roughly every six to eight weeks. The roadmap lists a long series of completed items through June 2026, which suggests active development rather than maintenance-only mode.

Upgrade cost is the practical concern. Because alembic is a dependency and the roadmap records a Postgres migration for user data, releases can carry schema changes. The README does not describe a downgrade procedure. The safe pattern is to read the release notes for the version you are moving to, back up the database, and test the migration on a copy before touching production. The Python floor is 3.12, per requires-python, with 3.13 also classified as supported, so plan your runtime accordingly.

## Conclusion

Adopt DocsGPT if you need private document retrieval, source citations and agent tooling on infrastructure you control, and you are willing to run Docker Compose plus the Python 3.12 backend and Vite frontend. Do not adopt it if you want a hosted service with no operational work, or if your corpus is small enough that a plain embedding index would do. Before committing, verify three things: that your chosen model provider is configured in the .env file the setup script writes, that the ingestion connectors you need (SharePoint, Confluence, sitemaps, audio) behave as the roadmap claims, and that the upgrade path from your pinned version to the next release does not require a Postgres migration you have not planned for.

## FAQ

### What is DocsGPT?

DocsGPT is an open-source AI platform for building agents and assistants over your own documents, with document analysis across PDF, Office, web and audio formats, multi-model support including local inference, and API connectivity for agents. It is MIT licensed and ships as a Flask backend plus a React frontend deployed with Docker Compose.

### Is there an open source ChatGPT alternative?

DocsGPT is one: it is MIT licensed, runs on your own infrastructure through Docker Compose, and can use local models via Ollama or llama_cpp instead of a hosted provider. It is aimed at document search and agents rather than general conversation.

### What is the best AI for documents?

That depends on your constraints. DocsGPT is built specifically for document work: it ingests PDF, DOCX, CSV, XLSX, EPUB, Markdown, HTML, JSON, PPTX, images and audio, and answers with source citations. If you need to keep documents on your own hardware, its local model support is the relevant feature.

### Is Google Doc AI free?

DocsGPT is not Google Doc AI and does not integrate with it as far as the repository shows. DocsGPT itself is MIT licensed and free to self-host, though you still pay for whatever model provider or local hardware you run it on.

### What is doc AI?

In this context it means AI applied to documents: ingesting files, indexing them, and answering questions with citations. DocsGPT is an open-source implementation of that idea, covering PDF, Office, web, image and audio inputs with multi-model support.

## Sources

- [arc53/DocsGPT on GitHub](https://github.com/arc53/DocsGPT)
- [License: MIT](https://github.com/arc53/DocsGPT/blob/main/LICENSE)
- [Project website](https://app.docsgpt.cloud/)
- [README](https://github.com/arc53/DocsGPT/blob/main/README.md)
- [Releases](https://github.com/arc53/DocsGPT/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/arc53-docsgpt