reflex-chat is a ChatGPT clone where Python covers the UI too
A ChatGPT clone built in Reflex
At a glance
- What is it?
- A small Reflex app that demonstrates LLMs in ChatGPT format, with sessions you can create and delete and a fully Python interface. The setup path still opens with a paid OpenAI subscription and an API key in the environment.
- Who is it for?
- Use reflex-chat as a starting point if you want a working ChatGPT style interface written entirely in Python and you already have an OpenAI key and a way to pay for the API. Do not treat it as a product to deploy unchanged: the MIT license and the hosted demo at chat.reflex.run make it easy to copy, while the README documents no persistence, no authentication, no streaming behaviour and no deployment step, so anything beyond a local demo is yours to build.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 166 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.
Star history
- reflex-dev/reflex-chat343 ★ · +1
| Repository | 2026-09-15 | 2026-11-13 |
|---|---|---|
| reflex-dev/reflex-chat | 342 | 343 |
1 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The interface is Python too, not a template with a Python backend
The feature list leads with a claim worth reading closely: 100% Python-based, including the UI, using Reflex. That includes the interface code, not just the server side, which is why the same document can say no knowledge of web development is required to use it and still leave room for people who want to restyle it. The styling route runs through Reflex, with a pointer to the Reflex styling overview for details. In practice the split of work is that the app defines state, callbacks and layout in Python, and Reflex handles the browser side. That is also why the customization promise is cheap to state and hard to grade, since how far you can go depends on how much of the styling surface Reflex exposes rather than on anything this repository controls.
A ChatGPT clone whose first requirement is a paid OpenAI subscription
The very first thing the setup asks for is a valid OpenAI subscription, and the key goes into an environment variable named `OPENAI_API_KEY`:
export OPENAI_API_KEY="YOUR_OPENAI_API_KEY" # replace me!This is the one part of the project that is not optional. Despite the ChatGPT format and the ChatGPT clone framing, nothing here talks to ChatGPT itself. It talks to the OpenAI API, which is billed separately from any ChatGPT subscription you may already pay for. So the cheapest way to evaluate this repository is not to read the code but to price an API key. Two things follow from the setup as written: the key is read from the environment rather than from a settings file, and no alternative provider is wired up in the documented path, even though the feature list promises you can swap out any LLM.
The dependency floors are lower bounds, not pinned versions
Two dependencies are declared, and both are open ended. requirements.txt asks for reflex at 0.7.11 or newer and openai at 1.78.1 or newer, with no upper bound on either:
pip install -r requirements.txtThe stated prerequisite is Python 3.10 or newer, and the two pip packages named as needed are `reflex` and `openai`, the same two the requirements file resolves. Open ended floors are convenient while the app is young, and they also mean your environment is whatever pip resolves on the day you install, not what the author tested against. If you plan to keep a deployment, pin both packages yourself and record the versions, because nothing in the repository does it for you. There is also no lock file at the top level: what ships there is a requirements file, an rxconfig.py, a chat directory, a docs directory and an assets directory.
reflex init runs once, reflex run runs every time
The run step is two commands with different jobs:
reflex init
reflex run`reflex init` is the one-time setup that scaffolds the app where Reflex expects to find it, and `reflex run` is the loop you use afterwards. Treating them as a pair on every launch is the obvious mistake, since reinitialising an existing project can overwrite the local scaffolding Reflex generates. The clone step comes before both, as you would expect:
git clone https://github.com/reflex-dev/reflex-chat.gitWhat the repository does not spell out is what `reflex run` needs in order to serve the app, or whether the port it picks matches the hosted demo at chat.reflex.run. Those are the details you will end up discovering by running it rather than by reading.
Swap out any LLM is a claim the setup path never demonstrates
Easily swap out any LLM sits in the feature list as a single line, and it is the line with the least behind it. The documented setup does the opposite: it asks for an OpenAI subscription, exports an OpenAI key, installs the openai package, and leaves it there. The package list is the tell. Since `openai` is a hard requirement rather than an optional extra, a provider swap is not a matter of changing one environment variable name; it means editing the code that constructs the client, and the README does not point at where that code lives. That is a reasonable thing to ask of a demo app whose stated purpose is to demonstrate LLMs in a ChatGPT format, and it is also the first thing you would have to write yourself if the demo was the point.
Chat sessions can be created and deleted, and that is the whole list
The feature list names exactly two session operations: create a chat session and delete a chat session. Nothing else about session handling is described. There is no mention of renaming, exporting, listing what came before, pinning a conversation, or keeping a session across a page reload, and the repository is small enough that the absence is informative rather than merely an omission from a summary. Responsive design for various devices is claimed alongside it, so the interface is at least meant to hold up on a phone, but how a conversation behaves when you switch devices is not part of what is documented. Treat the session list as the specification: a new conversation and a way to throw one away.
The app code sits in chat/, with docs and assets beside it
The top level of the repository is small enough to describe in one line: .github/, .gitignore, LICENSE, README.md, assets/, chat/, docs/, requirements.txt and rxconfig.py. Two things stand out. The application code lives in a chat directory rather than at the root, so the interesting Python is one level down. And a docs directory exists at the top level, next to a README that is a couple of hundred words long, which suggests more written material than the README itself points a reader toward. The rxconfig.py file is the one other artifact at the root that matters to Reflex projects, since that is where the app configuration lives, and it is the file you will edit first when you rename the app or change how it is served.
Editorial conclusion
Use reflex-chat as a starting point if you want a working ChatGPT style interface written entirely in Python and you already have an OpenAI key and a way to pay for the API. Do not treat it as a product to deploy unchanged: the MIT license and the hosted demo at chat.reflex.run make it easy to copy, while the README documents no persistence, no authentication, no streaming behaviour and no deployment step, so anything beyond a local demo is yours to build. Check three things before you start: that your Python is 3.10 or newer, that reflex 0.7.11 and openai 1.78.1 are the floors you can live with, since the pins are open ended, and that `reflex init` runs once before `reflex run`. There are no GitHub releases, and the last push to main is dated 2 June 2026.
Frequently asked questions
What is reflex-dev/reflex-chat and what is it built with?
It is a Python web app that demonstrates LLMs in a ChatGPT format, written entirely in Python including the UI, using the Reflex framework. It is MIT licensed and is published with a hosted demo at chat.reflex.run.
What do I need before running reflex-chat?
A valid OpenAI subscription, an API key exported as OPENAI_API_KEY, and Python 3.10 or newer. The two pip dependencies are reflex and openai, installed with pip install -r requirements.txt.
Which versions of Reflex and the OpenAI package does reflex-chat require?
requirements.txt sets lower bounds rather than exact pins: reflex at 0.7.11 or newer and openai at 1.78.1 or newer. There is no upper bound on either and no lock file at the top level of the repository.
Can reflex-chat use a model other than OpenAI?
The feature list says you can easily swap out any LLM, but the documented setup only wires up OpenAI: it requires an OpenAI subscription, an OPENAI_API_KEY value and the openai package as a hard dependency. No alternative provider is shown in the setup path.
What can reflex-chat do with chat sessions?
The documented session features are creating a chat session and deleting a chat session. No renaming, exporting, or persistence across reloads is described, and the app also claims a responsive design for various devices.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/reflex-dev-reflex-chat)Star history chart for your README
[](https://hysenlabs.com/projects/reflex-dev-reflex-chat)Was this useful?