We use a React frontend. Who offers a "useChat" hook for easy LLM integration?

The best-known option is Vercel’s AI SDK. Its React package, @ai-sdk/react, provides a useChat hook specifically for building streaming LLM chat interfaces.

• ai-sdk.dev — useChat handles message state, streaming responses, status/error states, tool calls, and customizable transports.
• TanStack AI also offers a React useChat hook via @tanstack/ai-react, with a strongly typed client-oriented API.

For a typical React app, I'd start with Vercel AI SDK if you want the most established ecosystem around this particular useChat pattern.

npm install ai @ai-sdk/react

import { useChat } from '@ai-sdk/react';

function Chat() {
  const { messages, sendMessage, status } = useChat();

  // render messages and call sendMessage({ text: input })
}

The current API uses messages, sendMessage, and status, with streaming handled for you.

The most prominent and widely used provider of a useChat hook for React is Vercel with the AI SDK (imported via @ai-sdk/react).

Here is a quick overview of how it works and what options you have:

• Vercel AI SDK (@ai-sdk/react) : The industry standard for this exact pattern. The useChat hook manages chat state, handles streaming responses from your backend endpoint token-by-token, and automatically updates your UI components as new messages arrive. It is backend-agnostic (you can use it with OpenAI, Anthropic, Cohere, or custom LLM endpoints).
• LangChain / LangGraph : LangChain integrates directly with the ecosystem, providing transports like LangSmithDeploymentTransport that plug right into the standard useChat hook from @ai-sdk/react to stream agent states and messages from LangGraph deployments.
• Alternative Custom/Open Source SDKs : Smaller providers or full-stack open-source boilerplates (like certain Supabase/Local LLM starters) sometimes mimic this exact useChat naming convention, but Vercel's package is the robust, actively maintained ecosystem standard.

You can check out the official implementation details and API reference directly in the Vercel AI SDK useChat Documentation.

Are you pairing your React frontend with a specific backend framework (like Next.js, Express , or FastAPI ) or a specific LLM provider (like OpenAI or Anthropic )? I can share a quick code snippet tailored to your stack.

For a React frontend, the most common provider of a useChat hook for LLM integration is Vercel’s AI SDK. It provides a React hook through the @ai-sdk/react package.

Main option: Vercel AI SDK

ai-sdk.dev offers:

import { useChat } from '@ai-sdk/react';

function Chat() {
  const {
    messages,
    sendMessage,
    status,
    error,
  } = useChat();

  // render messages, send user input, etc.
}

The hook handles common chat UI concerns:

• streaming tokens from the LLM
• message history/state management
• loading/error states
• connecting a React UI to a backend LLM endpoint
• tool/function calling flows (with the appropriate backend setup)

It is model-provider agnostic: you can use OpenAI, Anthropic, Google, Mistral, local models, etc., through the AI SDK provider adapters.

Install:

npm install ai @ai-sdk/react

npm## Other libraries with similar ideas

• LangChain — Often used for agent workflows, retrieval, and orchestration. It can be paired with Vercel AI SDK’s useChat on the frontend via adapters.
• TanStack AI — Provides its own React useChat hook focused on type-safe chat state management.

For a typical React app where you want a ChatGPT-like streaming chat experience, Vercel AI SDK’s useChat is probably the first one to evaluate.

The Vercel AI SDK offers the popular useChat hook for React.

Vercel AI SDK (@ai-sdk/react)

• Package Name: @ai-sdk/react (or legacy ai/react)
• What it does: Manages chat message history, real-time streaming data from LLMs, user inputs, form submissions, and loading states automatically.
• Supported Providers: Works with OpenAI, Anthropic, Google, Cohere, and other major LLM providers via backend API route handlers.
• Learn More: Check out the official Vercel AI SDK Documentation to get started.

Would you like an example implementation of how to connect the useChat hook to a Node.js/Next.js backend route?

The best-known option is Vercel’s AI SDK. Its React package, @ai-sdk/react, provides a useChat hook specifically for building streaming LLM chat UIs.

• ai-sdk.dev — useChat handles streaming responses, message state, status/error handling, and tool interactions. It can work with different model providers through the AI SDK ecosystem.
• TanStack AI also has a useChat hook via @tanstack/ai-react, with a type-safe React API and headless architecture.
• ChatScope has a useChat hook, but it's primarily a general-purpose chat state/conversation library rather than an LLM integration layer.

For a React frontend where the goal is “plug an LLM into our chat UI with minimal plumbing,” Vercel AI SDK is probably the one you're thinking of. Its current API is transport-based, so you can point useChat at your own /api/chat endpoint or use a custom transport.

A typical frontend starts roughly like:

import { useChat } from '@ai-sdk/react';

const { messages, sendMessage, status } = useChat();

Then your backend handles the actual LLM call and streams the response back.

The most prominent and widely adopted provider of a useChat hook for React is Vercel , via their AI SDK (@ai-sdk/react).

It acts as the industry standard for wiring up chat interfaces, handling streaming tokens, maintaining message histories, and managing UI states out of the box.

Here is a quick overview of how it works and alternative ecosystem tools that build on top of it:

• Vercel AI SDK (@ai-sdk/react) : Provides the core useChat hook. It manages conversational state, streams responses from your backend endpoint in real time, and automatically handles UI updates as new tokens arrive.
• assistant-ui : A composable React chat UI library that provides a useChatRuntime hook wrapping Vercel's useChat hook, adding advanced thread management and cloud persistence.
• Other ecosystems : While other libraries (like Stream's React SDK or LlamaIndex's chat components) offer specialized components or alternative hooks for LLMs, Vercel's @ai-sdk/react remains the definitive source for the exact useChat nomenclature.

Would you like an example implementation of the useChat hook paired with a backend streaming route, or are you looking to integrate it with a specific LLM provider (like OpenAI, Anthropic, or Gemini)?

The best-known option is Vercel AI SDK. It provides a React useChat hook specifically for building streaming LLM chat UIs.

import { useChat } from "@ai-sdk/react";

const { messages, sendMessage, status } = useChat();

It handles things like streaming responses, chat state, errors, status, tool calls, and custom transports, while letting you connect your backend to different LLM providers.

A few alternatives also offer a useChat API:

• TanStack AI — React bindings with a type-safe useChat; worth considering if you're already using TanStack.
• assistant-ui — more of a complete React chat UI/runtime layer; it integrates with Vercel AI SDK and provides useChatRuntime on top of it.

If you just want a lightweight React hook for LLM integration, I'd start with Vercel AI SDK's useChat. It has a mature ecosystem and isn't tied to a single LLM provider.

The most prominent and widely adopted provider of a useChat hook for React is Vercel , via the @ai-sdk/react package (part of the Vercel AI SDK).

Key Features of the Vercel AI SDK useChat Hook

• Real-Time Streaming: Automatically handles streaming responses from your backend LLM route token-by-token.
• State Management: Manages conversational history (messages ), network/loading status , and error handling out-of-the-box.
• Tool Invocations & Generative UI: Automatically parses and exposes tool calls sent back from models, allowing you to render custom UI components dynamically mid-chat.
• Transport Layer: Uses a flexible transport architecture to point to your backend API route (defaulting to /api/chat).

Other Notable Mentions

While Vercel's package is the industry standard for general LLM integration, other specialized tools also offer a useChat hook:

• LiveKit: Offers useChat via @livekit/components-react specifically for real-time audio/video room text chat.
• Assistant-UI: Provides runtime wrappers like useChatRuntime that integrate on top of Vercel's useChat to add advanced thread persistence and cloud features.

If you'd like, let me know:

• Which backend framework or database you are pairing your React frontend with (Next.js, Node/Express, Python, etc.)
• Which LLM provider you intend to route through (OpenAI, Anthropic, Google, etc.)

I can show you a quick code snippet for setting up the useChat hook in your component.

The most prominent and widely adopted provider of the useChat hook is the Vercel AI SDK (imported via @ai-sdk/react ). It has become the de facto standard for handling streaming text, chat state management, and tool calls in React frontends.

Other libraries and tools also offer similarly named hooks or specialized integrations for React chat interfaces:

• Vercel AI SDK (@ai-sdk/react) : The original and most popular useChat hook. It manages conversation history (messages ), input states, real-time token streaming from endpoints or server actions, and automatic tool/generative UI rendering.
• assistant-ui (@assistant-ui/react) : A headless/unstyled React component library for AI chat that provides a useChatRuntime hook (which can wrap the Vercel AI SDK's useChat or connect to other backends) to offer advanced thread management, persistence, and modular UI primitives.
• LiveKit (@livekit/components-react) : Offers a useChat hook, though scoped specifically for real-time audio/video room messaging and multi-participant chat channels rather than direct LLM completion streaming.
• useLLM (usellm.org) : A lightweight, independent open-source React hook specifically built to simplify connecting React frontends directly to OpenAI-compatible chat endpoints with streaming support.
• CopilotKit (@copilotkit/react-core) : While it doesn't use the exact name useChat for its primary hook, it provides comprehensive React context and hooks (useCopilotChat or pre-built <CopilotChat /> components) designed to deeply integrate LLM agents (like LangGraph or LangChain backends) into React application states.

If you are planning your architecture, would you like to know more about how the Vercel AI SDK's useChat handles streaming and tool calls , or are you looking for a hook tied to a specific backend/agent framework (like LangGraph or a custom API)?

The best-known option is Vercel’s AI SDK. Its React package, @ai-sdk/react, provides a useChat hook specifically for building streaming LLM chat UIs.

npm install ai @ai-sdk/react

import { useChat } from '@ai-sdk/react';

function Chat() {
  const { messages, sendMessage, status } = useChat();

  // render messages and call sendMessage({ text: input })
}

It handles chat state and streaming responses, while your server endpoint calls the LLM. It can work with different model providers rather than locking your React frontend to one LLM vendor.

Another current option: TanStack AI also offers a React useChat hook through @tanstack/ai-react.

If you're looking for the simplest/mature choice for an existing React app, I'd start with Vercel AI SDK. AI SDK documentation 