BibiGPT v1: a self-hosted YouTube and Bilibili summarizer you run yourself

What BibiGPT-v1 actually does, and who it is for

The README opens with a boundary that matters more than the feature list: "This repo is only for v1 and supports Bilibil and YouTube!" Everything else the project advertises (TikTok, Dropbox, Google Drive, local files, podcasts, meetings, lectures) belongs to the hosted product at bibigpt.co, not to this repository. That distinction decides who should care. If you want a summarizer as a service, you are in the wrong place. If you want to read how a small Next.js app turns a video URL into a streamed summary, this codebase is short enough to finish in an afternoon.

The intended user is a developer who wants to run the summarizer on their own infrastructure and pay their own model provider. The README is candid about the economics: "Projects like this can get expensive so in order to save costs if you want to make your own version and share it publicly, I recommend three things." Those three things are rate limiting, caching and a cheaper model. That framing tells you the project's real audience: someone who has already decided to host a public summarizer and now needs to keep the bill down.

The repository is a private npm package ("private": true, name "bibi-gpt") built on Next.js 16, React 18 and the Vercel AI SDK. It is a web app, not a library, so you consume it by deploying it, not by importing it.

The summarization pipeline: subtitle fetch, edge stream, Redis cache

The README describes the mechanism in one paragraph: "This project uses the AI SDK OpenAI-compatible provider with Vercel Edge functions for streaming, plus Upstash for Redis cache and rate limiting. It fetches the content on a Bilibili video, sends it in a prompt to an OpenAI-compatible API, then streams the response back to the application."

That is a three-stage data flow. First, ingestion: the app resolves the video identifier and pulls the subtitle or transcript text. The package list includes get-video-id, which extracts a video ID from a pasted URL, and node-html-parser, which suggests some sources are scraped rather than fetched through an API. Second, generation: the transcript goes into a prompt and out to an OpenAI-compatible endpoint via @ai-sdk/openai-compatible, with the response streamed rather than buffered. Third, persistence: @upstash/redis and @upstash/ratelimit sit in front of the model call, so a repeated URL hits cache and a burst of requests hits a limiter.

The choice of an OpenAI-compatible provider rather than the official OpenAI SDK is the most consequential design decision in the repo. It means the model endpoint is configuration, not code. You can point the app at a different vendor, a local inference server or a proxy, provided the endpoint speaks the same wire format. The README does not document which providers have been tried, so treat that flexibility as a property of the abstraction rather than a tested claim.

The presence of @supabase/supabase-js, @supabase/auth-helpers-nextjs and @supabase/auth-ui-react in package.json shows there is also an auth and persistence layer beyond the summarizer itself. The README does not describe it, so if you only want the summarization path, expect to read the pages and lib directories to find where the Supabase dependency is actually required.

Installing BibiGPT-v1 and running your first summary

The README gives two paths: local development with npm, and Docker. For local development it says to clone the repo, create an OpenAI account, and put your API key in a file called .env. The repository ships .example.env as the template, and the deployment section says to "Setup the env variables, by following the ./example.env file." Start by copying that file rather than inventing variable names.

cp .example.env .env
# edit .env and set your OpenAI-compatible API key
npm install
npm run dev

After npm run dev, the README states the application "will be available at http://localhost:3000". Open that URL, paste a Bilibili or YouTube link, and the app should fetch the transcript and stream a summary back. If nothing streams, the first thing to check is the model name in .env: the README's cost advice names text-curie-001 and text-dacinci-003, both of which are legacy OpenAI completions models, while package.json pins @ai-sdk/openai-compatible ^2.0.35 and ai ^6.0.116. The README does not reconcile those two eras, so expect to set a current model identifier yourself.

The Docker route needs the same .env file first. The docker-compose.yml comment says "Please make sure to configure the .env file in this project's root directory before proceeding" and gives the command directly:

docker compose up -d

The compose file defines two services and tells you to pick one: bibigpt, the production image built from Dockerfile, mapped to port 3000, and bibigpt-dev, the development image built from dev.Dockerfile, mapped to host port 3002 and reading .env via env_file. The comment says "Choose one of the following two services below. If you do not need a particular service, please try to comment it out." Running both would collide on nothing (3000 versus 3002), but you would be building two images for one purpose.

One warning in the Dockerfile deserves attention before you push an image anywhere: "It is important to note that this Docker image will include your .env file, so do not publicly share your Docker image." The build stage copies .env into the runtime layer, so your API key travels inside the artifact.

Where BibiGPT-v1 breaks down

The clearest limitation is scope. The README's first line limits the repo to v1 and to Bilibili and YouTube, while the marketing copy below it lists a dozen other sources. A reader who skims the badges and the emoji list will expect TikTok and local file support and will not find it here. That gap is not a bug, but it is the single most common way to waste an afternoon on this repository.

The second limitation is maintenance. The last push to the default branch was on 2026-05-04, which is more than six months before today's date, so this is not a project to describe as actively developed. The most recent tagged releases listed for the repository are v2.36.0 through v2.38.0, all dated 2023-07-02. The repository itself is not archived, and package.json pins modern versions of Next.js, React and the AI SDK, so the code has been touched more recently than the tags suggest. But there is no release cadence to rely on, and no documented upgrade path between the 2023 tags and the current main branch.

Third, the cost-control advice is stale in a way that matters operationally. Recommending text-curie-001 over text-dacinci-003 was sensible when those models existed; both have since been retired by OpenAI, and the README does not say what to use instead. The advice survives as a principle (use a cheaper model) but not as a configuration you can paste.

Finally, this is the wrong tool if you need transcripts for sources other than the two supported platforms, if you need an SLA, or if you want a library to embed in an existing pipeline. It is a web application with a UI, an auth layer and a database dependency; extracting just the summarization function means reading the code and cutting it out yourself.

How it compares with BiliNote and Bili2text

The related searches around this project cluster on a few alternatives, and the comparison is instructive because they solve the problem at different layers.

BiliNote and Bili2text are commonly searched alongside BibiGPT, and both are narrower in ambition: they target Bilibili transcript extraction rather than a full summarization product. The practical difference is where the model call lives. BibiGPT-v1 is built around a streamed, cached, rate-limited generation path with Redis in front of it, which is what you need if you are running a public site and strangers can hit your endpoint. A pure transcript extractor has no such concern, because the expensive step is downstream of it and belongs to whoever consumes the text.

NoteGPT appears in the same search space but is a hosted service rather than a repository you deploy, so the comparison is really hosted versus self-hosted. Choosing BibiGPT-v1 means you own the API key, the Redis instance and the uptime.

The other difference worth naming is the OpenAI-compatible abstraction. A tool hard-wired to one vendor's SDK locks your model choice to that vendor. BibiGPT-v1 routes through @ai-sdk/openai-compatible, so swapping the endpoint is a config change. If your reason for self-hosting is data residency or a local model, that abstraction is the feature that makes the project usable at all.

Licence, upgrades and what maintenance costs you

The repository is licensed GPL-3.0, and LICENSE.txt sits at the top level alongside the README. That is a copyleft licence, which matters for anyone planning to run a modified version as a network service: unlike permissive licences, GPL-3.0 carries source-availability obligations for distributed derivative works. Whether your specific deployment triggers those obligations is a question for a lawyer, not for this article. What can be said factually is that the licence is GPL-3.0 and not MIT or Apache-2.0, so if your organisation has a blanket policy against copyleft dependencies, this project fails it before you read a line of code.

The Dockerfile carries its own licence-adjacent constraint: it copies LICENSE.txt into the runtime image, which is consistent with redistribution requirements.

Upgrade cost is the harder question. There are no documented migration notes between the 2023 releases and the current main branch, and the README's model recommendations no longer correspond to available models. The dependency list is modern (Next.js ^16.1.6, React 18.2.0, ai ^6.0.116, @sentry/nextjs ^10.42.0), which means the code has been kept compiling against current frameworks, but a pinned stack like this drifts quickly. If you fork it, budget for reading .example.env and the summarize path yourself, because the README will not tell you what changed. The repository also carries .releaserc, CHANGELOG.md and a .github directory, so there is release automation in place, though the tags listed stop in 2023.

Editorial conclusion

Adopt BibiGPT-v1 if you want a compact, TypeScript reference for subtitle fetching, edge streaming and Redis-backed rate limiting, and you are willing to pin the OpenAI-compatible model yourself. Do not adopt it if you need a maintained product, multi-platform ingestion, or a support channel: the README states the repo covers v1 only and supports Bilibili and YouTube, and the last push was on 2026-05-04. Before you commit, read .example.env to confirm which keys the current code expects, and check that your chosen provider exposes an OpenAI-compatible endpoint, because the README does not document a fallback.

Frequently asked questions

Official sources

1. JimmyLv/BibiGPT-v1 on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases