Model or dataset
OvidijusParsiunas/deep-chat avatar
OvidijusParsiunas/deep-chat

Deep Chat: one tag, three connection models, and a changelog that misses its own breaking change

Fully customizable AI chatbot component for your website

3,748 stars460 forksTypeScriptMIT

At a glance

What is it?
Deep Chat is a MIT licensed web component that adds an AI chat to a site with one line of markup, and the interesting decisions are all in the three ways it can reach a model: your own service, a vendor API called straight from the browser, or a model hosted in the browser itself. The documentation is unusually honest about the second of those, and unusually quiet about what the most recent release actually removed.
Who is it for?
Deep Chat is a good fit when you want a chat UI quickly and are willing to write the small server side that speaks its format, since that is the mode it recommends and the one the server template examples support.
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 22 days ago.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • OvidijusParsiunas/deep-chat3,748 ★ · +37
Star history
Repository2026-09-142026-11-15
OvidijusParsiunas/deep-chat3.7k3.7k

37 Stars in the last 62 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The README changelog and the release titles disagree about 2.5.1

The latest updates section lists a `2.5.1` update whose contents are Requesty, liteLLM and Dify becoming available in `directConnection`, better `webModel` support across modern browsers, and some bug fixes. The release titles say something different. Version 2.5.0 is titled "Requesty, LiteLLM and more", published 2026-07-19, which is where those three integrations actually arrived. Version 2.5.1 is titled "Deprecating OpenAI Assistants API", published 2026-08-27. So the breaking change in the release history, the removal of a whole API surface, appears nowhere in the README's own changelog, while the README's 2.5.1 list mostly restates the previous release. Anyone upgrading from a version before August should read the release notes rather than this page, because the page will not tell them the Assistants integration is gone.

Direct connection puts the API key in the browser and says so

The component can talk to a hosted model without any server of yours, and the cost of that is spelled out plainly:

code
<deep-chat directConnection='{"openAI":true}'/>

<deep-chat directConnection='{"openAI":{"key": "optional-key-here"}}'/>

Both forms are shown, one with no key and one with one supplied in the markup. The note underneath is unambiguous: this approach is for local, prototyping and demo purposes only, because it exposes the API key to the browser, and when you are ready to go live you should switch to the `connect` property with a proxy service. That is the correct advice and it is in the same place as the examples, which is more than most component libraries do. The open question is only what happens to a deployment that skipped the note: a key in client-side markup is a key you will rotate, and the README's wording leaves open whether the component does anything to discourage it beyond telling you not to.

One tag, three packages and a mode with no server at all

The core install is one package and one element:

code
npm install deep-chat

with `<deep-chat></deep-chat>` in the markup, and a separate package `deep-chat-react` when you are in React, where the syntax differs per framework. A third package, `deep-chat-web-llm` is what makes the third connection mode possible: set `webModel` to true and the component runs a model entirely in the browser, with no server and no connection at all. The repository tree explains the packaging, since `component/` holds the core and `other-packages/` holds the framework wrappers, with `website/`, `assets/` and `example-servers/` alongside. So the same element can be pointed at your own endpoint, at twenty-odd vendor APIs from the browser, or at a model that never leaves the machine, which is three quite different trust models behind one tag name.

connect expects your service to speak the component's own format

The recommended path is the `request` property with a URL:

code
<deep-chat request='{"url":"https://service.com/chat"}'/>

The condition attached to it is that your service has to understand the request and response formats Deep Chat uses, which is why the documentation points at a Connect section and at server template examples, and why the repository carries an `example-servers/` directory. Nothing translates a vendor API for you, so the work is on your side. Two escape hatches exist for when the endpoint cannot be changed. The `interceptor` properties augment the objects in transit, and a `handler` function takes over the request code entirely. That combination is what makes the component usable against an existing backend that already has its own protocol: intercept on the way out, handle on the way in, and leave the service alone.

llms.txt is an installation path aimed at a code assistant

There is an `llms.txt` file at the root of the repository, and the README gives it a section of its own under a heading about installing with AI. The suggested prompt is a single quoted sentence instructing a coding assistant to use that file to add a chat component to a website. So the project publishes a machine-readable description of itself specifically so an assistant can consume it, and the whole configuration surface, twenty-odd integrations, three connection modes, the focus and upwards display modes and the storage options, is expected to be reachable from that one file rather than from a human reading documentation. That is a deliberate choice about who configures the component, and it is unusual enough to be worth knowing before you write your own integration guide. The rest of the configuration lives on the documentation site at deepchat.dev.

Three display modes and a notes file in the repository root

Most of the recent work has been about what is on screen rather than what is in it. Focus mode, added in 2.2.0, displays only the latest message exchanges. `upwardsMode` from 2.4.0 populates messages upwards, and the same release added a `scrollButton` and `hiddenMessages` component for long conversations. `browserStorage` from 2.2.2 keeps messages in the browser with no backend integration at all, and 2.4.0 extended it to store `inputText` and `scrollHeight` so a reload restores where you were. `htmlWrappers` from 2.3.0 standardise custom styling across messages and can wrap streamed output as it arrives, which is what lets a remarkable plugin such as Katex render math inside a reply. Also in the tree is `notes.txt` at the repository root, a working file that shipped with the package rather than being kept elsewhere.

Editorial conclusion

Deep Chat is a good fit when you want a chat UI quickly and are willing to write the small server side that speaks its format, since that is the mode it recommends and the one the server template examples support. Decide deliberately between the three modes rather than by convenience at prototype time: direct connection is documented for prototyping only because the key ends up in the browser, and webModel keeps everything on the machine at the cost of whatever the browser can actually run. Read the release notes rather than the README's update list before upgrading, since the 2.5.1 deprecation of the OpenAI Assistants API is not mentioned there. And if you would rather not hand-write the endpoint, the repository's llms.txt exists so a coding assistant can do that part for you.

Frequently asked questions

How do I add Deep Chat to my website?

Install with `npm install deep-chat`, or `npm install deep-chat-react` for React, then put `<deep-chat></deep-chat>` in your markup; the exact element syntax varies by framework. Then choose a connection: the request property for your own service, directConnection for a browser-side vendor API key while prototyping, or webModel together with the deep-chat-web-llm module to run a model in the browser.

What is Deep Chat?

A fully customizable AI chat web component that can be injected into a site with one line of markup. It connects either to your own service through the request property or directly from the browser to more than twenty popular AI APIs, and it handles file sending, webcam photos, microphone recording, speech to text, text to speech and speech to speech.

Is Deep Chat free?

The component is MIT licensed and installed from npm. What costs money is the model behind it. Running a model in the browser through webModel needs no service at all, while a direct connection to a hosted API is documented for local, prototyping and demo use only, because it exposes the API key to the browser, with a proxy service recommended for anything live.

Official sources

  1. License: MIT
  2. OvidijusParsiunas/deep-chat on GitHub
  3. Project website
  4. README
  5. Releases
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/ovidijusparsiunas-deep-chat.svg)](https://hysenlabs.com/projects/ovidijusparsiunas-deep-chat)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/ovidijusparsiunas-deep-chat.svg)](https://hysenlabs.com/projects/ovidijusparsiunas-deep-chat)

Was this useful?