TL;DR
- MIT-licensed and backend-free: 166 files, 600 KB of TypeScript, and zero test files
- Speaks an Anthropic-compatible Messages API that accepts Claude model names as aliases
- Server-side search returns AES-256-GCM encrypted results the client cannot decrypt
System Requirements
| RAM | Node 22.12+, pnpm, and a modern browser: Chrome or Edge 105+, Safari 16+, Firefox 110+ |
| GPU | None, the model runs on DeepSeek hosted API |
| VRAM | A DeepSeek API key, entered in the app Settings and stored in your browser |
DeepSeek put the client of its chat app on GitHub under MIT on 13 November. It is 600 KB of TypeScript, it has no backend, and the code is not the interesting part. The interesting part is what the code talks to: a DeepSeek endpoint that implements Anthropic's Messages API, answers to Claude model names, and now carries the app's own features as public API. If you have an Anthropic SDK pointed somewhere today, this is the shortest migration path any Chinese lab has offered you.
What actually shipped
The repository is deepseek-ai/chat-demo. It was created on 12 November and the first commit landed the next afternoon. There are two commits, one contributor, and two releases half an hour apart. Everything below was read from the GitHub API and the raw source on the date at the foot of this article.
| Fact | Value |
| Created / first commit | 2026-11-12T08:08:19Z / 2026-11-13T14:02:56Z |
| Licence / language | MIT / TypeScript |
| Files / total bytes | 166 / 709,943 (90 KB of that is the pnpm lockfile) |
| Source tree | 155 files, 599,656 bytes (components 309,226, services 242,746) |
| Stars / forks / watchers | 2,034 / 342 / 8 |
| Commits / contributors | 2 / 1 |
| Releases | v0.1.0 at 14:03:17Z, v0.1.1 at 14:33:18Z |
| Test files | 0 |
| CI workflows | 1, a GitHub Pages deploy |
| Issues / pull requests / Discussions | off / off / off |
The repository was renamed. It started life as deepseek-chat-demo, and the README's link to the Releases page still points at the old name, surviving only because GitHub redirects it. The live build runs on GitHub Pages and returns a healthy 200. You can also download a zip from Releases, unpack it, and double-click index.html.
A client, not the app, and not a harness
Two things this is not, because both are easy to assume from the announcement.
It is not a harness. In DeepSeek's own vocabulary that word means DeepSeek Harness, the plugin-based agent runtime we took apart in August and re-measured 39 days later, most recently in the shape of the dsh-superagent prototype. None of that is in this repository. There are no agents, no plugins and no tool loop.
It is also not the production app. The README calls it "a static chat demo powered by the DeepSeek API", and that is honest: this is a reimplementation of the client, not the code that serves chat.deepseek.com. What makes it worth your afternoon is that the reimplementation is faithful enough to need the app's real feature set, so DeepSeek had to expose that feature set publicly for the demo to work at all.
No backend, by design
There is no server component. The browser holds your API key in localStorage, your conversations and original attachments in IndexedDB, and it talks straight to the API. Nothing about the app knows who you are.
The build goes to some trouble to support being opened from a local file. In rspack.config.ts the output sets publicPath: 'auto' so asset paths resolve relative to wherever the script actually sits, and the HTML plugin uses scriptLoading: 'defer' rather than module scripts, because classic deferred scripts load from a file:// page and ES modules do not. Browser targets are Chrome and Edge 105 or newer, Safari 16, Firefox 110.
Pointing it somewhere else is one argument. createConfig({ apiOrigin, devServer }) takes the API origin, defaults it to https://api.deepseek.com, and injects it into the bundle as __API_ORIGIN__. The dev server runs on port 8090 and can proxy, so a local gateway in front of your own model is a config change rather than a fork.
The API is Anthropic-compatible, and that is the news
The file to read is src/services/api/types.ts. Its header comment names the protocol outright: Messages API, Anthropic-compatible format, with a link to DeepSeek's own documentation. The endpoints are POST /anthropic/v1/messages for chat and POST plus DELETE /anthropic/v1/files for attachments.
Authentication is the x-api-key header, and a source comment notes that Authorization: Bearer also works. Attachments require anthropic-beta: files-api-2025-04-14, and the client is careful to send that header only when a request actually carries a file. Content arrives as typed blocks over Server-Sent Events, a one-way stream of named events the server pushes as it generates.
Two deviations from the convention you are probably used to. The stream ends on a message_stop event and there is no [DONE] sentinel, so code written against OpenAI-style streams will hang waiting for a line that never comes. And a response whose content type is not text/event-stream is treated as a protocol fault rather than parsed hopefully.
The error taxonomy in client.ts is worth stealing. Five kinds: http, stream, network, interrupted and protocol. When a stream dies without the server saying why, the message is deliberately left blank, and the comment explains the rule in one line: do not speculate about the cause. More client libraries should be that disciplined.
Claude model names are accepted as aliases
The client offers two models, deepseek-flash and deepseek-v4-pro. DeepSeek's API documentation adds a detail the client does not need but you might: the endpoint accepts Claude model names as aliases. Anything beginning claude-opus is served by deepseek-v4-pro, and any other claude name is served by deepseek-flash.
That is not an accident of string parsing. It means an application already written against the Anthropic SDK, with Claude model names hardcoded through it, can be repointed at DeepSeek by changing a base URL and a key.
| Model | Cache hit, off-peak / peak | Cache miss, off-peak / peak | Output, off-peak / peak |
| deepseek-flash | 0.003 / 0.006 | 0.15 / 0.30 | 0.60 / 1.20 |
| deepseek-v4-pro | 0.022 / 0.044 | 0.66 / 1.32 | 1.98 / 3.96 |
Prices are per million tokens as published on DeepSeek's pricing page, which uses a dollar sign without naming a currency code. Context is 1M with a maximum output of 384K. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays, excluding Chinese public holidays, and off-peak is half the peak rate.
One housekeeping note for anyone following our model coverage: the documentation now lists deepseek-v4-flash and deepseek-v4-flash-vision-exp as legacy aliases served by deepseek-flash and billed at the Flash price. The names we used in our pieces on V4 Flash and V4.1 Flash still resolve, but they now point at a moving target rather than a fixed checkpoint. If you would rather pin a checkpoint than chase an alias, that is an argument for running the weights yourself, which is what libosmos does with V4.1 Flash on a single Strix Halo. deepseek-v4-pro is the API's top tier, we have not covered it, and nothing we read suggests open weights for it.
The four extensions, and what extension mode costs you
On top of the Anthropic shape sit four DeepSeek additions, all four documented and all four exercised by this client.
| Extension | Shape | What it does |
| deepseek_web_search | Server-side tool | Searches the web, and searches while thinking when thinking is on |
| deepseek_read_url | Server-side tool | Reads links found in the latest user message |
| latest_reminder | A third message role | Supplies date, location, platform and language for the turn |
| safety_check | Request field, level high or low | Reviews model input and output; low is the default |
The search tools run on DeepSeek's side, not yours. You declare them and the server performs the retrieval, reporting back through blocks with one of five kinds: search, deep_search, read_link, image_search and deep_image_search. The identifiers encode the kind, in the form srvtoolu_ followed by a short code, a sequence number and 32 hex characters.
Declaring either search tool, or setting safety_check.level to high, puts the request into what the source calls extension mode. That has a price the documentation buries: in extension mode document file blocks are rejected with a 400. You can send images, not PDFs. If your application uploads documents and also wants server-side search, you cannot have both in one request.
Two smaller details for anyone writing a parser. The encrypted_index field on citations is annotated as always an empty string, a vestigial piece of the Anthropic shape. And the signature on a thinking block, delivered through signature_delta, is just the message id of the response, which is also the value of the x-ds-request-id response header.
The search results come back encrypted
This is the finding that stopped us. When the server performs a web search on your behalf, each result carries a displayable title, URL, snippet, site name and favicon, plus a field called encrypted_content. The source comment states what it is and what you can do with it: the search summary, AES-256-GCM encrypted and Base64 encoded, which the client cannot decrypt for display.
Reading a link works the same way. A successful read_link returns a signature holding the encrypted page, and the client's job is to hand that signature back verbatim on later turns so the server can restore the page context it already has. The client never sees the page it caused to be fetched.
The replay rules follow from that. Of the tool blocks in a conversation, only read_link calls and their results go back to the server. Search results are not replayed at all, and neither is historical thinking. So the retrieved corpus lives on DeepSeek's side for the life of the conversation, and your client holds a receipt.
Two consequences worth being clear about. You cannot use this API as a cheap web-scraping proxy, which is almost certainly the point. And you cannot fully reconstruct a conversation's grounding from your own stored data, because the part that did the grounding was never yours.
latest_reminder is five comma-joined fields
The latest_reminder role is the most app-like thing in the protocol, and the implementation is smaller than the idea. It sits immediately before the user message it belongs to and carries context the model would otherwise have to guess.
In createLatestReminder it is five values joined with commas: the date, the weekday name, a location name, the literal string Web, and the interface language. Date and weekday come from the browser's local time zone, with a comment noting this is to stop a UTC date rolling over a day early.
The location is worth a sentence because it is not what you might fear. It comes from a picker in Settings, backed by a 12.7 KB table of provinces and cities, and falls back to a region name. There is no geolocation call anywhere in the client. If you leave the setting empty the field is an empty string, and the model simply does not learn where you are.
It reads the real app's export
Here is the detail that undercuts the word "demo". The history importer in src/services/chat/history does not read a format invented for this repository. It reads export_format_version: 3, in a zip named deepseek_data- plus a date, holding a manifest.json, one JSON file per session, a session index and the original images.
That is the DeepSeek app's own export. The giveaway is the handling of user.json: the importer tolerates it sitting between the manifest and the sessions, skips it, and the documentation notes that this project does not export account information. You only write code to skip a file you expect to receive.
The same document maps content types this client never displays, including TIP, CONTENT_RISK, PARTIAL_FILE_READ and TOOL_IMAGE_SEARCH, and reply states FINISHED, INCOMPLETE, WIP, FAILED, CONTEXT_LENGTH_EXCEEDED, TIMEOUT and CONTENT_FILTER. That is a production data model with a demo's user interface in front of it.
The message tree is honest about its invariants: nodes are linked by id and parent_id, a parent id must be lower than its child's, roles alternate, the root is a question, and current_message_id selects the visible branch. One asymmetry to know before you rely on round-tripping: a locally generated reply is marked prefix: true and can be continued, while every imported reply is set to prefix: false and cannot. The flag is never sent to the API.
981 file extensions, and who they are for
The upload allowlist in src/services/uploadExts.ts holds 981 extensions, with a comment noting that heic and heif are deliberately absent. Scroll it and the audience becomes obvious. Alongside the expected code and document formats sit wxml, wxss, wxs, axml, acss, sjs, swan, ttml, ttss, qml and qss: the markup and style formats of WeChat, Alipay and Baidu mini-programs.
Nobody adds eleven mini-program dialects by accident. This is a tool shaped for developers inside the Chinese app ecosystem, and the allowlist says so more plainly than any announcement would.
| Upload purpose | Applies to | Size cap |
| none sent | Images | 64 MB |
| rich_layout_recognition | PDF, Word, PowerPoint | 64 MB |
| user_data | Text, code, tables, ebooks | 32 MB |
Fifty attachments maximum, three uploading at once, and the server enforces its own file count and storage quotas on top. One form-encoding gotcha from the source: purpose must be appended to the multipart body before file, not after.
And one thing to read twice if you care about data hygiene. Uploaded files have no expiry, and the README states that clearing all local chats deletes your conversations and local attachments but not the files already uploaded to the API. The delete button in Settings is a local delete.
We checked the CORS policy ourselves
A browser-only client that talks directly to a third-party API only works if that API allows it, so we tested the claim rather than taking it. A preflight request to https://api.deepseek.com/anthropic/v1/messages reflects whatever Origin you send straight back in access-control-allow-origin, with access-control-allow-credentials set to true.
We tried the project's own GitHub Pages origin, two unrelated domains, a localhost development server and the literal value null, which is what a page opened from disk sends. All five returned 200 and all five were echoed back. That is a fully open cross-origin policy, and it is the reason the double-click-the-file workflow functions at all.
It is also the risk. Your API key lives in browser storage on whatever origin served the page, which means any script injected into that origin can read it, and nothing prevents somebody hosting a convincing copy of this app at an address of their choosing. Running it from your own machine or your own domain is fine. Typing a key into someone else's deployment is a decision, not a default.
What it does not do
The gaps are mostly honest ones for a two-day-old repository, but they will bite in a specific order.
There is no way to register your own tools. The client defines a tool_use block type so it can recognise one, but the request type only accepts the two DeepSeek server tools, so this is a chat client and not an agent. Documents and server-side search are mutually exclusive, per extension mode. Imported replies cannot be continued. Export drops citation markers, non-image originals, the model name, thinking signatures, original tool-call identifiers, structured error details, usage figures and any branch you were not on. There is no migration path from older local databases, only the current format.
And there are no tests. Not a reduced suite, not a smoke test: zero test files across 166, with one CI workflow that deploys the Pages site.
Third repository in a row with the door shut
Issues are off. Pull requests are off, to the point that the API returns 404 for the endpoint. No Discussions, no wiki, and not a single GitHub topic. That is the same posture as the dsh-superagent prototype, and it makes three consecutive DeepSeek releases published as artefacts to read rather than projects to join.
The contrast with that prototype is sharper than the similarity. dsh-superagent shipped roughly 1.4 bytes of test code for every byte of logic. This ships none. Same month, same organisation, same closed front door, opposite engineering standard, which suggests the two repositories were never meant to be judged the same way.
Running it
Node 22.12 or newer and pnpm, and the whole thing is four commands. The last two are optional and only there if you want to verify the claims above for yourself.
node -v; pnpm -v; git --version
# clone and run the client locally
git clone https://github.com/deepseek-ai/chat-demo.git
cd chat-demo && pnpm install
pnpm dev # http://localhost:8090
# or build a folder you can open straight from disk
pnpm build && ls dist
# check an API key without being billed for anything
curl -s https://api.deepseek.com/models \
-H "Authorization: Bearer $DEEPSEEK_API_KEY" | head -c 300
# confirm the endpoint answers a file:// origin, which is what makes
# the no-backend build work at all
curl -s -X OPTIONS https://api.deepseek.com/anthropic/v1/messages \
-H 'Origin: null' \
-H 'Access-Control-Request-Method: POST' \
-D - -o /dev/null | grep -i access-control
The key check is the one to keep. The client validates keys with a plain GET /models, and the source comment confirms what that implies: it costs nothing, so it is a safe liveness probe for a key you are not sure about.
Who should run this
If you want a private chat front end, this is the shortest route to one. It is MIT, it has no backend to operate, it stores everything in your browser, and it imports the history export from the official app. Build it once, drop dist/ on any static host, and you have a chat client whose only outbound dependency is an API you already pay for.
If you maintain something built on the Anthropic SDK, read the alias mapping and the pricing table together. A second provider that accepts your existing model strings, with Flash input at 0.15 per million tokens off-peak on a cache miss, is a real hedge. Budget time for the two protocol deviations rather than the integration: the missing [DONE] sentinel and the extension-mode document restriction are where your code will break.
If you are designing a retrieval-augmented product, the encryption design is the lesson here. DeepSeek lets its own client display a search result without letting it read one, and keeps the retrieved page server-side behind an opaque signature the client replays. That is a coherent answer to a problem most teams solve by shipping the whole corpus to the browser and hoping nobody looks.
Who should skip it: anyone wanting an agent. There is no tool registration here, and if that is what you came for, the dsh-superagent prototype and the broader DeepSeek Harness ecosystem are the right doors.
Sources and further reading
Your under-ten-minutes move: open src/services/api/types.ts and read the comments, not the types. They are the only published description of how DeepSeek's server-side search actually behaves, down to which blocks you are expected to replay and which ones you will never be allowed to read. If you have ever wired up a search tool and wondered where the boundary between client and server should sit, somebody has already drawn you one.
Not independently tested. Every repository statistic, file size, commit, star, fork, release, file count and byte total above was read from the public GitHub REST API and the raw source files on the date below. Prices, model names and alias mappings were read from DeepSeek's own API documentation on the same date and will move. All client behaviour described is taken from the project's source and its documentation, not from a running deployment. The one exception is the cross-origin policy in the CORS section, which we checked ourselves with preflight requests against the public endpoint.
Date checked: 2026-11-15