zeronsh/chat: Unified AI Chat for Claude, GPT, and Gemini

zeronsh/chat: Unified AI Chat for Claude, GPT, and Gemini

Developers building with large language models face a fragmented landscape. Each provider—Anthropic, OpenAI, Google—offers distinct APIs, response formats, and streaming behaviors. Switching between them means managing multiple keys, interfaces, and conversation histories. For teams evaluating models or engineers who simply want one consistent chat experience, this friction adds up fast. zeronsh/chat addresses this directly: it's an open-source, unified AI chat application that brings Claude, GPT, and Gemini into a single interface. Built with modern web tooling and released under the MIT License, it offers resumable streams, integrated research tools, and fast session navigation without locking you into any single provider.

What is zeronsh/chat?

zeronsh/chat is a sleek, modern AI chat application maintained by the GitHub user zeronsh. As of its last commit on July 9, 2026, the project has accumulated 250 stars and 21 forks—modest but growing traction that suggests genuine utility for its target audience. The repository is written primarily in TypeScript and distributed under the MIT License, making it freely available for personal and commercial use.

The project sits at the intersection of two active trends in developer tooling: AI model aggregation (single interfaces for multiple LLM backends) and local-first/real-time web architecture (via its use of Zero for state synchronization). Unlike many closed-source chat clients, zeronsh/chat is fully inspectable and hackable. Its choice of TanStack Start for the framework and Vercel AI SDK for AI orchestration signals alignment with the React^{↗ Bright Coding Blog} ecosystem's cutting edge—particularly for developers already invested in Vercel's deployment platform or TanStack's data-fetching patterns.

The timing is relevant. As model capabilities diverge—Claude's reasoning strengths, GPT's broad tool ecosystem, Gemini's multimodal features—developers increasingly need to compare outputs side-by-side or route queries to optimal models. A unified interface reduces context-switching and API management overhead without requiring a backend proxy you build yourself.

Key Features

Resumable Streams
The standout technical feature is stream resumption. If a browser page refreshes mid-generation, the conversation state persists and the response continues. This is non-trivial to implement: it requires server-side stream buffering or client-side reconstruction of partial tokens. For long-running Claude reasoning chains or GPT-4 extended outputs, this eliminates the frustration of losing progress to accidental reloads.

Fast Navigation Between Sessions
The UI optimizes for quick context switching. Rather than a single linear chat history, zeronsh/chat structures conversations as discrete sessions accessible through rapid navigation patterns. This suits power users managing multiple parallel threads—debugging assistance, code review, research, creative writing—without scrolling through one monolithic log.

Integrated Search via Exa
The application bundles Exa (formerly Metaphor) for web search. This isn't a generic "search the web" claim—Exa provides neural search with structured output, enabling the chat to ground responses in retrieved documents rather than model hallucination. For developers using AI for technical research, this bridges the gap between conversational interfaces and citation-backed answers.

Research Tool
Beyond search, a dedicated research function operates within the chat interface. The README doesn't detail implementation specifics, but the positioning suggests deeper information synthesis—possibly multi-step retrieval, source aggregation, or structured report generation—rather than single-query search.

Theming
Multiple visual themes customize the interface. While seemingly cosmetic, this matters for developers spending extended sessions in the tool and for teams wanting white-label flexibility.

Use Cases

Multi-Model Evaluation for ML Engineers
When prototyping applications that will call LLM APIs in production, engineers need to benchmark latency, output quality, and cost across providers. zeronsh/chat provides a controlled environment for A/B testing: identical prompts sent to Claude, GPT, and Gemini with comparable streaming UX. The resumable streams ensure long evaluation runs aren't fragile to browser instability.

Technical Research with Verified Sources
Developers investigating new frameworks or debugging obscure errors benefit from the Exa integration. Instead of switching between a chat interface and search tabs, research and synthesis happen in one flow. The neural search backend surfaces technically relevant results that keyword search might miss.

Persistent Coding Assistance
Long debugging sessions with AI assistance often span hours. Fast navigation between conversation threads lets developers maintain separate contexts: one thread for React component architecture, another for database query optimization, a third for CI/CD troubleshooting. Resumable streams protect against losing state during deep focus work.

Team Knowledge Base Augmentation
With MIT licensing and a TypeScript/React codebase, teams can fork and extend zeronsh/chat to connect internal documentation, runbooks, or API specs through the research tool. The unified provider interface means switching between internal fine-tuned models and commercial APIs without UX changes.

Installation & Setup

The README does not provide explicit installation commands. Based on the documented stack (TanStack Start, React, TypeScript), the standard workflow for a project of this architecture would be:

# Clone the repository
git clone https://github.com/zeronsh/chat.git
cd chat

# Install dependencies (npm, yarn, or pnpm)
npm install

# Configure environment variables for AI providers
# Create .env.local with keys for Anthropic, OpenAI, Google
cp .env.example .env.local
# Edit .env.local with your API keys

# Start the development server
npm run dev

Step-by-step explanation:

1. Clone: Retrieves the latest source from the default branch (last updated July 9, 2026).
2. Install: Resolves dependencies including TanStack Start, Vercel AI SDK, Zero, and Shadcn/UI components.
3. Environment setup: The application requires valid API keys for each LLM provider you intend to use. The README does not specify exact variable names—check the source or [INTERNAL_LINK: environment-configuration-best-practices] for patterns common in Vercel AI SDK projects.
4. Dev server: TanStack Start typically runs on localhost:3000 with hot module replacement.

For production deployment, the TanStack Start + Vercel AI SDK combination suggests Vercel as the natural target, though the MIT license permits hosting anywhere.

Real Code Examples

The README does not contain embedded code snippets. This section reflects the current state of documentation rather than invented examples. Developers should consult the repository source directly for implementation patterns.

Based on the documented stack, the Vercel AI SDK integration likely follows patterns like:

// Typical pattern for multi-provider setup with Vercel AI SDK
// (inferred from stack documentation, not from README)
import { anthropic } from '@ai-sdk/anthropic';
import { openai } from '@ai-sdk/openai';
import { google } from '@ai-sdk/google';
import { streamText } from 'ai';

// Provider selection based on user preference or model routing
const providers = {
  claude: anthropic('claude-3-5-sonnet-20241022'),
  gpt: openai('gpt-4o'),
  gemini: google('gemini-1.5-pro-latest')
};

async function generateResponse(providerKey: string, prompt: string) {
  const model = providers[providerKey as keyof typeof providers];
  
  const result = await streamText({
    model,
    prompt,
    // Resumable stream configuration would extend this
  });
  
  return result.toDataStreamResponse();
}

The actual implementation in zeronsh/chat may differ—this illustrates the architectural pattern the documented stack enables. For authoritative code, examine app/routes/ or API route handlers in the cloned repository.

Advanced Usage & Best Practices

Stream Resumption Reliability
Treat resumable streams as a convenience, not a guarantee. For critical long-running generations, consider implementing client-side logging or explicit "continue from checkpoint" prompts. The feature reduces friction but doesn't replace robust error handling in production pipelines.

Provider Key Rotation
With multiple API keys in one application, implement tiered access: development keys with strict rate limits, production keys with higher quotas. The unified interface makes it tempting to expose all providers to all users—gate this at the application layer, not just the UI.

Exa Search Optimization
Exa's neural search excels with natural language queries but may underperform with highly specific syntax (exact error codes, version numbers). Combine it with direct documentation lookups for hybrid coverage. The research tool likely orchestrates this; verify in source whether it does multi-source fusion.

Zero Sync Patterns
Zero (rocicorp.dev) provides local-first state synchronization. For self-hosters, understand its sync server requirements and conflict resolution semantics before deploying to multi-user scenarios. The README doesn't detail operational concerns—evaluate Zero's own documentation for production readiness.

Comparison with Alternatives

Trade-offs to consider:
ChatGPT offers the most polished consumer experience but locks you into OpenAI's ecosystem. LibreChat provides broader provider support and plugin architecture but lacks the modern TanStack Start foundation and resumable stream implementation. zeronsh/chat occupies a middle ground: opinionated about stack (React/TanStack/Zero), technically current, and focused on stream reliability rather than maximum configurability.

FAQ

What API keys are required?
At minimum, one key for any provider you use: Anthropic, OpenAI, or Google. The README doesn't specify if keys are optional or if the app degrades gracefully without them.

Can I self-host without Vercel?
The MIT License permits this, but TanStack Start's deployment patterns are optimized for Vercel. Other Node.js hosts should work with configuration adjustments.

Does it support local LLMs (Ollama, llama.cpp)?
The README doesn't mention local model support. The Vercel AI SDK can interface with OpenAI-compatible local servers, but this would require code modification.

How does stream resumption work technically?
The README claims the feature but doesn't document implementation. Likely server-side stream buffering or client-side reconstruction of the Vercel AI SDK's data stream.

Is there a Docker^{↗ Bright Coding Blog} setup?
Not documented in the README. Standard Node.js containerization should apply.

What's the browser compatibility?
Unspecified. TanStack Start targets modern browsers; expect issues with Internet Explorer or legacy Safari.

How active is maintenance?
Last commit July 9, 2026 with 250 stars and 21 forks. Evaluate issue responsiveness and commit frequency for your risk tolerance.

Conclusion

zeronsh/chat serves developers who want a unified, hackable AI chat interface without surrendering to closed ecosystems. Its technical choices—TanStack Start, Zero, Vercel AI SDK—reflect current best practices in React-based full-stack development, while features like resumable streams and Exa-integrated search solve concrete friction points in multi-model workflows.

The project is best suited for: developers comparing LLM outputs, teams building AI-augmented internal tools, and engineers comfortable extending TypeScript/React codebases. It's not the most mature option (250 stars, thin documentation), but the MIT license and modern stack lower the barrier to contribution and customization.

If you're managing multiple AI provider accounts and tired of context-switching between browser tabs, explore the repository, clone it, and evaluate whether its architecture fits your workflow.