# ChuanhuChatGPT: a Gradio web UI for many LLMs, from GPT-5 to local ChatGLM

> ChuanhuChatGPT is a Python and Gradio interface that puts hosted and locally deployed language models behind one chat window, with file-based QA, web search and an agent mode. It is a self-hosted tool with a real install cost, and its last push was on 2026-04-30.

**GaiZhenbiao/ChuanhuChatGPT** — GUI for ChatGPT API and many LLMs. Supports agents, file-based QA, GPT finetuning and query with web search. All with a neat UI.

- Repository: https://github.com/GaiZhenbiao/ChuanhuChatGPT
- Website: https://huggingface.co/spaces/JohnSmith9982/ChuanhuChatGPT
- Stars: 15,271 · Forks: 2,196
- Language: Python
- License: GPL-3.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/gaizhenbiao-chuanhuchatgpt

## What ChuanhuChatGPT actually solves for a multi-model team

Most chat clients bind you to one vendor. ChuanhuChatGPT's premise is the opposite: one Gradio interface that can talk to OpenAI, Azure OpenAI, Google Gemini Pro, Claude, MiniMax, DeepSeek, Inspur Yuan 1.0, XMChat, Midjourney and DALL-E 3 through their APIs, and to ChatGLM, LLaMA, StableLM, MOSS and Qwen when those run locally. The README groups them in a two-column table under API models and locally deployed models, which is the clearest statement of intent in the repository.

The audience is engineers and technically comfortable users who already hold API keys or a local inference setup. The README describes features aimed at that group: adjustable LLM parameters, a replaceable api-host, custom proxy support, and load balancing across multiple api-keys. None of those matter to someone who just wants a chat box. They matter a great deal to a team routing traffic through a corporate proxy or spreading requests over several keys.

The project also carries features that go past plain conversation. The README lists Chuanhu Assistant (described as AutoGPT-like), online search, a knowledge base for answering questions from files, local LLM deployment, and fine-tuning of gpt-3.5. Each of those is a separate subsystem with its own dependencies, which is why requirements.txt is long and why requirements_advanced.txt exists as a separate file.

## How the Gradio app, config.json and model backends fit together

The entry point is ChuanhuChatbot.py at the repository root. Running it starts a Gradio server; the Dockerfile exposes port 7860 and sets the environment variable dockerrun to yes before launching the same script. That port is the default the container advertises, not a value the README promises for a bare Python run.

Configuration lives in config.json. The README's quick start says to copy config_example.json and rename the copy, then fill in the API-Key and other settings. The deployment notes add two keys explicitly: server_name set to 0.0.0.0 and server_port set to your port to expose the app on a server, and share set to true to obtain a public link, with the caveat that the program must be running for that link to work.

The repository layout shows where behaviour is implemented: modules/ holds the Python code, configs/ holds configuration material, locale/ holds translations, templates/ and web_assets/ hold the front end, and readme/ holds the translated README files. The dependency list confirms the shape of the stack. gradio 4.29.0 and fastapi 0.112.4 form the web layer, langchain 0.1.14 with langchain-openai and langchain_community backs the agent and retrieval features, faiss-cpu 1.7.4 handles vector search for file-based QA, and per-vendor SDKs (openai 1.16.2, anthropic 0.18.1, google.generativeai, ollama, groq) sit alongside document parsers such as PyPDF2, pdfplumber, python-docx and openpyxl. That mix is the architecture in miniature: a web UI on top of a retrieval and tool-calling layer on top of vendor clients.

One design consequence is worth stating plainly. Because the model list is assembled from separate SDKs and each feature has its own dependency, the project's surface area is large. The README itself says features like XMChat and Midjourney do not support streaming, so the interface cannot behave identically across every backend.

## Installing ChuanhuChatGPT and running a first conversation

The README gives a three-command quick start. Clone the repository, enter the directory, install the requirements.

```bash
git clone https://github.com/GaiZhenbiao/ChuanhuChatGPT.git
cd ChuanhuChatGPT
pip install -r requirements.txt
```

After that, the README instructs you to copy config_example.json inside the project folder, rename the copy to config.json, and fill in the API-Key and other settings. The repository does not ship a config.json, only the example, so this step is mandatory rather than optional.

```bash
cp config_example.json config.json
```

Then start the app.

```bash
python ChuanhuChatbot.py
```

The README states that a browser window opens automatically, at which point you can chat with ChatGPT or another model. The repository also provides run_Linux.sh, run_Windows.bat and run_macOS.command for platform-specific launching, and a Dockerfile if you prefer a container.

```dockerfile
FROM python:3.10-slim-buster as builder
RUN pip install --user --no-cache-dir -r requirements.txt
FROM python:3.10-slim-buster
COPY . /app
WORKDIR /app
ENV dockerrun=yes
CMD ["python3", "-u", "ChuanhuChatbot.py","2>&1", "|", "tee", "/var/log/application.log"]
EXPOSE 7860
```

That excerpt is condensed from the Dockerfile in the repository; the real file installs build-essential, curl, cmake, pkg-config and libssl-dev plus Rust in the builder stage before installing the Python packages, and copies the Rust toolchain into the final image. Note that the advanced requirements line is commented out in the Dockerfile, so a container built as shipped does not include requirements_advanced.txt.

For a server deployment, the README's deployment section points at config.json rather than command-line flags. Set server_name to 0.0.0.0 and server_port to your port to make the app reachable from outside the host, and set share to true if you want a public link, remembering that the process has to stay running for that link to resolve. On Hugging Face Spaces, the README recommends duplicating the Space rather than using the shared instance, because the copy may respond faster.

## Where ChuanhuChatGPT is the wrong tool

The README's own troubleshooting section is the most honest part of the repository. Before looking anything up, it tells users to pull the latest changes and reinstall dependencies, and it gives the commands: download the ZIP and overwrite, or run git pull with the -f flag against the main branch, then pip install -r requirements.txt again. That is a reasonable instruction for a fast-moving project, but it also means a working installation can break when the dependency set shifts, and there is no documented rollback path in the README. The release history supports the point: the most recent release is 20250815, and before that 20241204 and 20240919-4, whose title is "Safety patches." Between releases, users are expected to track main.

The pinned versions in requirements.txt are another constraint. gradio is pinned to 4.29.0, openai to 1.16.2, langchain to 0.1.14 and pydantic to 2.5.2. Pinning makes the install reproducible but puts the project at odds with any other Python environment that needs newer versions of the same packages. If you already run a recent LangChain or Pydantic in the same interpreter, expect conflicts, and consider the Dockerfile or a virtual environment instead.

There is also a scope limit. The README's quick start assumes a single-user, local install. Multi-user history isolation is mentioned as a feature, but the README does not describe authentication, access control or a hardened deployment model. Running this on a public address with share set to true is a decision the documentation does not prepare you for. If you need a managed service with an uptime commitment and no Python environment to maintain, this project is the wrong shape entirely.

## ChuanhuChatGPT compared with plain Gradio chat examples

The obvious alternative is to build a small Gradio app yourself around one vendor SDK. That gives you full control, a dependency list you can keep to a handful of packages, and no GPL obligations if you distribute it. The trade-off is that you would have to write the parts ChuanhuChatGPT already ships: streaming display, conversation history with search and rename, LaTeX and table rendering, code highlighting, file upload and retrieval over PDFs and spreadsheets, and adapters for each provider. For a single model and a handful of users, that is a weekend of work and probably the better choice.

A second alternative is the project's own Hugging Face Space, linked from the README as an online demo with a one-click duplicate option. That removes the install entirely. It does not remove the configuration: you still need your own API keys, and the README notes that duplicating the Space is recommended because the shared instance may be slower. The practical difference is where the process runs and who patches the dependencies.

The comparison that matters most is breadth against depth. ChuanhuChatGPT's value is the number of backends behind one interface, including local ChatGLM, LLaMA, Qwen, MOSS and StableLM. A single-vendor client will always have tighter integration with that vendor's newest features. This project's model list is updated by contributors, and the README's GPT-5 note shows that happening, but there is a lag between a vendor shipping something and this repository supporting it.

## Licence, maintenance and what an upgrade costs

ChuanhuChatGPT is licensed under GPL-3.0, as stated in the repository's LICENSE file and shown in the README badge. For internal use that distinction rarely bites. If you modify the code and distribute the result, or offer it as a network service in a way the licence treats as distribution, the copyleft terms apply to your derivative. That is a reason some teams will not embed it in a closed product. This is a description of the licence, not legal advice; read the LICENSE file and, if the answer matters commercially, ask a lawyer.

The repository is not archived, and the last push was on 2026-04-30. That is roughly four and a half months before the date of this article, so the project is not receiving daily commits, and the release cadence is slow: 20250815 was the most recent tag, with 20241204 before it. Treat it as a maintained project with an irregular rhythm rather than a fast-moving one.

The upgrade cost follows from the same facts. Because the README's troubleshooting path is to pull main and reinstall requirements.txt, an upgrade is not a tagged-release operation for most users. Expect to reinstall dependencies, expect the pinned versions to move, and expect configuration keys to change between versions. There is no documented migration guide for config.json in the README; the wiki's update log is where the project points for change history. Docker users get a more repeatable path, but the Dockerfile as shipped does not install requirements_advanced.txt, so advanced features may need a custom build.

## Conclusion

Adopt ChuanhuChatGPT if you want one self-hosted Gradio window across hosted APIs and local models and you are willing to maintain a Python environment and a config.json. Skip it if you need a hosted service with an uptime commitment, or if you cannot accept GPL-3.0 terms for a modified distribution. Before committing, confirm that your Python version satisfies the pinned dependencies in requirements.txt, and check the wiki's FAQ page for the proxy and model configuration cases that match your setup.

## FAQ

### What does ChuanhuChatGPT support beyond the OpenAI API?

The README lists API access to Azure OpenAI, Google Gemini Pro, Claude, MiniMax, DeepSeek, Inspur Yuan 1.0, XMChat, Midjourney and DALL-E 3, plus locally deployed ChatGLM, LLaMA, StableLM, MOSS and Qwen. It also notes that XMChat and Midjourney do not support streaming.

### How do I install ChuanhuChatGPT?

The README's quick start clones the repository, changes into the directory, runs pip install -r requirements.txt, copies config_example.json to config.json, fills in the API key, and then runs python ChuanhuChatbot.py. A browser window opens automatically afterward.

### What does the GPT in ChatGPT stand for?

The repository does not explain the acronym; its README uses GPT as part of model names such as GPT-4, GPT-4o and GPT-5 without expanding it. The project's own documentation is silent on the term's origin.

## Sources

- [GaiZhenbiao/ChuanhuChatGPT on GitHub](https://github.com/GaiZhenbiao/ChuanhuChatGPT)
- [License: GPL-3.0](https://github.com/GaiZhenbiao/ChuanhuChatGPT/blob/main/LICENSE)
- [Project website](https://huggingface.co/spaces/JohnSmith9982/ChuanhuChatGPT)
- [README](https://github.com/GaiZhenbiao/ChuanhuChatGPT/blob/main/README.md)
- [Releases](https://github.com/GaiZhenbiao/ChuanhuChatGPT/releases)

---

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