vercel/chatbot: a Next.js AI chatbot template you fork instead of configure

What vercel/chatbot actually is, and who forks it

The README describes Chatbot (formerly AI Chatbot) as a free, open-source template built with Next.js and the AI SDK that helps you build chatbot applications. That word, template, carries the whole judgement. This is not a library you add to an existing app, and it is not a hosted assistant you point at a document set. It is a repository you clone, rename and edit, with the chat surface, the streaming layer, the database schema and the sign-in flow already assembled. The intended reader is a TypeScript developer working in the Next.js App Router who would otherwise spend the first two weeks of a chat project rebuilding message lists, token streaming and conversation persistence. The repository's own framing is honest about the scope: the topics list ai, chatgpt, nextjs, react, redis and shadcn-ui, and the package name in package.json is simply chatbot, version 3.1.0, marked private. If you are looking for a drop-in widget to embed on a marketing site, this is the wrong shape of project, and no amount of configuration turns it into one.

The stack behind the chat surface: AI SDK, Drizzle, Neon and Blob

The README lists the moving parts plainly. Next.js App Router supplies routing, React Server Components and Server Actions. The AI SDK supplies a unified API for text generation, structured objects and tool calls, plus hooks for dynamic chat interfaces. Data persistence is split in two: Neon Serverless Postgres for chat history and user data, and Vercel Blob for file storage. Auth.js handles authentication. The repository layout corroborates this. There is a drizzle.config.ts at the top level, a lib/ directory that the package scripts reach into for migrations, an app/ directory holding the route groups, and a proxy.ts. The topics list includes redis, and .env.example defines REDIS_URL, so a Redis instance is expected even though the README's feature list does not explain what it stores. That gap is worth noting: the environment file is the more complete inventory of dependencies than the prose. Model access runs through the Vercel AI Gateway, with per-model provider routing configured in lib/ai/models.ts. The README names Mistral, Moonshot, DeepSeek, OpenAI and xAI as the included models, and states that the AI SDK lets you switch to direct providers such as OpenAI, Anthropic or Cohere with a few lines of code. So the routing layer is a default, not a lock-in, but changing it means editing TypeScript in lib/ai/models.ts rather than toggling a setting.

Installing vercel/chatbot and sending a first message

The README's local setup assumes a Vercel account, because it uses the Vercel CLI to pull environment variables. You need the variables defined in .env.example before the app will run. The README recommends Vercel Environment Variables but says a .env file is sufficient, and warns against committing it.

First install the CLI and link the directory, which creates a .vercel folder:

npm i -g vercel
vercel link
vercel env pull

Then install dependencies, apply the database schema and start the dev server. The db:migrate script in package.json runs npx tsx lib/db/migrate.ts, so this step needs POSTGRES_URL to be valid:

pnpm install
pnpm db:migrate
pnpm dev

The README states the app should then be running on localhost:3000. If you are not deploying to Vercel, the README says you must supply an AI Gateway key yourself by setting AI_GATEWAY_API_KEY in .env.local, because Vercel deployments authenticate through OIDC tokens automatically. That is the single most common reason a local copy boots and then fails on the first message. The other four variables in .env.example are AUTH_SECRET, BLOB_READ_WRITE_TOKEN, POSTGRES_URL and REDIS_URL. The file suggests generating the secret with openssl rand -base64 32. Once the server is up, sign in, pick a model from the selector and send a message; the AI SDK streams the reply into the message list. Vercel also offers a one-click deploy button for the template.

Where the template model bites: schema ownership and migration cost

Because this is a fork, every upstream change is a merge you perform by hand. There are no releases retrieved for this repository, so there is no changelog to read before you pull. The last push was on 2026-07-08, which is roughly two months before the date of writing, and the repository is not archived, so work is recent even though the release channel is silent. The practical consequence sits in the database layer. Chat history and user data live in Postgres under a Drizzle schema, and the build script runs tsx lib/db/migrate before next build. If you have added your own tables or columns, an upstream schema change arrives as a diff against files you have already modified. Drizzle gives you db:generate, db:migrate, db:push, db:pull, db:check and db:studio as separate commands, which is a reasonable toolkit, but none of it resolves a conflict between your columns and theirs. Teams that treat the initial clone as a scaffold and then diverge heavily should expect to track upstream selectively, or to stop tracking it. The template gives you a running start, not a subscription.

What vercel/chatbot is not: channels, no-code and non-Vercel defaults

The repository contains no integration for WhatsApp, Telegram, Messenger or any messaging platform. The app is a web chat surface built on Next.js routes. If your requirement is a bot inside a messaging app, this project does not address it, and the environment variables give no hint of a channel adapter. The same applies to lead generation or CRM workflows: there is no contact pipeline in the feature list, and no schema is described for anything beyond chat history and user data. The second limitation is deployment posture. The README is explicit that Vercel deployments authenticate to the AI Gateway automatically via OIDC, while non-Vercel deployments need AI_GATEWAY_API_KEY. That is a supported path, not a blocked one, but it means the happy path is Vercel, and every other host starts one configuration step behind. The third is effort. Choosing a model means editing lib/ai/models.ts. Adding a tool means writing AI SDK tool definitions. There is no admin panel described in the README for either.

Choosing between vercel/chatbot and a hosted assistant builder

The real alternative for most teams evaluating this repository is not another open source chat template but a hosted assistant platform, where you upload documents, configure a prompt in a browser and get an embeddable widget. The difference in approach is ownership versus operation. A hosted builder gives you a working assistant in an afternoon and keeps the retrieval pipeline, the vector store and the UI on someone else's servers; you cannot read the streaming code, and you cannot change how messages are persisted. vercel/chatbot gives you the opposite trade: you supply Postgres, Redis, Blob storage and an AI Gateway key, you run migrations, and in return the message list, the streaming layer and the auth flow are files in your repository that you can edit. The AI SDK's provider abstraction means the model choice is a code change rather than a vendor decision, and the README notes direct providers including OpenAI, Anthropic and Cohere are a few lines away. If your team already runs Next.js and Postgres, the marginal cost of this template is low. If your team does not write TypeScript, the hosted route is cheaper, and no amount of template quality changes that.

Licence, upgrades and the cost of staying current

GitHub reports the licence as NOASSERTION, which means the platform could not match the LICENSE file to a recognised licence identifier. The LICENSE file is present at the top level, so the terms exist in the repository, but they are not summarised by a standard SPDX label. Anyone adopting this for commercial work should read that file directly and have someone qualified confirm what it permits; this article cannot. On upgrade cost, the mechanics are visible in package.json. The project pins ai at 7.0.15 and @ai-sdk/react at 4.0.16, and depends on drizzle-orm, next, botid, the Vercel Blob and OTEL packages, CodeMirror modules and the shadcn/ui toolchain. There is a biome.jsonc and an ultracite check script for linting, plus Husky hooks wired through prepare. Playwright is configured with a test script that sets PLAYWRIGHT=True. That is a full modern frontend toolchain, and each of those dependencies moves independently. Because there are no releases to pin against, the upgrade unit is the commit, and the build script's migration step means a dependency bump and a schema change can land in the same pull.

Editorial conclusion

Adopt vercel/chatbot if you are a Next.js developer who wants an AI chat UI, streaming, persistence and auth already wired together and you are willing to edit TypeScript rather than fill in a settings form. Do not adopt it if you want a chatbot on WhatsApp, Telegram or Messenger, or a no-code assistant: those channels appear nowhere in the repository, and the app is a web chat surface. Before committing, verify four things: that your Postgres, Redis and Blob credentials are reachable from wherever you deploy, that `AI_GATEWAY_API_KEY` is set if you are not on Vercel, that `pnpm db:migrate` succeeds against a fresh database, and that the LICENSE file, which GitHub reports as NOASSERTION, matches the terms your organisation accepts.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. vercel/chatbot on GitHub