Open Source ChatGPT Alternatives

OpenClaw is an open source AI assistant that runs on your own computer and meets you in the channels you already use, from Discord and Slack to iMessage, Telegram and WhatsApp, with native apps for macOS, iOS, Android, Windows and Linux. It removes the need to sit in a vendor's chat window to reach an assistant.

A single Gateway acts as the local control plane for sessions, tools, events and channel connections, and the Control UI, the CLI and the TUI all connect to it. The same process serves one person on a laptop or a whole team, and only the configuration differs.

The pieces that matter for anyone weighing a self-hosted assistant.

• Local state: memory, credentials and session data stay on your hardware, and the project itself checks only for a daily version update.
• Swappable models: hosted and local providers plug in, so Claude, Codex or a local model becomes a configuration choice.
• Channels: WhatsApp, Telegram, Slack, Discord, Google Chat, Signal and iMessage all reach the same assistant.
• Companion apps: platform nodes add voice, canvas, camera, screen and device-local actions.
• Tools, skills and plugins: three extension points widen what the assistant can actually do.

The installer covers macOS, Linux and Windows and provisions a Node.js runtime when one is missing, with an npm package for people who manage Node themselves. Treat inbound messages as untrusted, since tools run on the host unless you configure sandboxing. Stewardship sits with an independent nonprofit foundation, and there is no paid tier or hosted service.

Hermes Agent is built around a learning loop. It creates skills from experience, improves them while using them, searches its own past conversations and builds a model of the person it works for across sessions.

It is not bound to a laptop. One gateway process serves Telegram, Discord, Slack, WhatsApp, Signal and the command line at once, with voice memo transcription and conversation continuity between them, so the agent can keep working on a cloud machine while you talk to it from a phone.

The project describes its own capabilities in five areas.

• Terminal interface: a full TUI with multiline editing, slash-command autocomplete, history, interrupt and redirect, and streaming tool output.
• Memory and recall: agent-curated memory with periodic nudges, full-text session search with summarization, and dialectic user modeling.
• Scheduled automations: a built-in cron scheduler runs daily reports, nightly backups or weekly audits unattended and delivers them to any platform.
• Delegation: isolated subagents handle parallel workstreams, and Python scripts call tools over RPC to collapse multi-step pipelines.
• Seven terminal backends: local, Docker, SSH, Singularity, Modal, Daytona and Vercel Sandbox, two of which hibernate when idle and wake on demand.

Any model works, whether through Nous Portal, OpenRouter, OpenAI or your own endpoint, and switching takes one command rather than a code change. Install scripts cover Linux, macOS, WSL2, Termux and native Windows, pulling in Python, Node.js and the other dependencies. It runs on a cheap VPS or a GPU cluster, suiting anyone who wants an agent that stays awake between sessions.

Open WebUI is a self-hosted front end for AI models that is built to run entirely offline. Point it at local Ollama models, at any OpenAI-compatible endpoint, or at several at once, and the interface stops being tied to whichever provider you happened to start with.

Setup runs through pip, uv, Docker or Kubernetes with kubectl, kustomize or helm, and tagged images exist for Ollama and CUDA deployments. It is also a progressive web app, so one deployment serves desktop, laptop and mobile with offline access on localhost.

The feature surface reaches well past a chat box.

• Retrieval: local RAG backed by nine vector databases, several extraction engines, hybrid search with reranking, and web search across dozens of providers.
• Plugins: filters, actions, pipes, tools and skills extend it, with MCP and OpenAPI tool servers connecting external services.
• Permissions: role-based access control with groups gives each user exactly the reach an administrator intends.
• Agents and memory: any base model can be wrapped with instructions, tools and knowledge, and the assistant remembers facts between conversations.
• Workspaces: notes with AI rewriting, shared channels, a calendar the models manage conversationally, and recurring automations.

Voice and video calls run through several speech engines, images are generated and edited with local or hosted backends, and a key-value storage API keeps artifacts such as journals, trackers and leaderboards. Markdown and LaTeX render throughout. It suits a team that wants one interface over many models without sending conversations anywhere it does not control.

Most agents today are one-off tools: no shared context, no memory worth the name, and constant manual hand-offs between windows and models. LobeHub answers that by treating agents as the unit of work, giving them a space where they are hired, scheduled and reported on like teammates.

Building one starts with the Agent Builder. You describe what you need once and the setup runs immediately, applying auto-configuration so the agent is usable straight away. Agents reach any model and any modality, and connect to a library of more than ten thousand tools and MCP-compatible plugins.

Collaboration is where the model of a team gets exercised.

• Agent Groups: the system assembles the right agents for a task and lets them work in parallel.
• Pages: several agents write and refine content together in one shared context.
• Schedule: runs happen at the right time, including while you are offline.
• Workspace: a shared space with clear ownership and visibility across an organization.
• White-box memory: structured, editable memory that you can inspect and correct.

Self-hosting comes as a Docker image or a one-click deployment on Vercel, Zeabur, Sealos or Alibaba Cloud, with an OpenAI API key supplied as an environment variable. LobeHub is under active development, so expect the feature list to keep moving.

GPT4All runs large language models privately on everyday desktops and laptops. There are no API calls to make and no GPU to rent: you download the application, pick a model and start a conversation on hardware you already own.

The stack builds on llama.cpp, which Nomic contributes to, and adds Nomic Vulkan for local inference on NVIDIA and AMD cards. A Python client wraps the same engine, so a script can load a GGUF model and open a chat session in a handful of lines.

The project covers more than the desktop chat window.

• Chat client: redesigned in version 3.0, with access to a wider range of model architectures.
• LocalDocs: chat with your own documents locally and privately.
• Python package: a pip install away, downloading and loading models on first use.
• GPU inference: quantized inference on NVIDIA and AMD hardware through Vulkan.
• API server: a Docker-based server exposing local models over an OpenAI-compatible endpoint.
• Integrations: LangChain, the Weaviate vector database and OpenLIT monitoring.

Installers exist for Windows, Windows on ARM, macOS and Ubuntu, with a community-maintained Flathub build. Windows and Linux builds want an Intel Core i3 second generation or AMD Bulldozer processor or better, the Linux build is x86-64 only, and macOS needs Monterey 12.6 or newer, with Apple Silicon giving the best results.

Building a private ChatGPT usually means gluing a vector store, a document pipeline and a permissions layer onto whichever model you picked. AnythingLLM ships all of that as one application that runs locally by default and needs no setup work first.

You connect a local or cloud model, ingest documents and start chatting within minutes. Support spans llama.cpp compatible models, OpenAI, Anthropic, Azure, Bedrock, Gemini, Ollama, LM Studio, Mistral and Groq among many others, alongside embedders, transcription models and vector databases.

Several features push it past a plain chat wrapper.

• Dynamic model routing: sends each conversation to the provider and model your rules select.
• Managed memories: the model retains information about you or a workspace across sessions.
• Scheduled tasks: recurring prompts run on a cron schedule with full agent capabilities.
• Skill selection: enables unlimited tools while cutting token use per query substantially.
• Agent builder: assembles custom agents and flows without code, with MCP compatibility.

Multi-user permissioning and the embeddable website chat widget are Docker-only, while desktop builds cover Mac, Windows and Linux. A developer API is available for custom integrations, and the team is separately working on Open Computer, an environment giving agents a whole machine to use.

Cherry Studio is a desktop client for talking to many language models from one window, running on Windows, macOS and Linux with no environment to prepare beforehand. Cloud services such as OpenAI, Gemini and Anthropic sit next to local models served through Ollama or LM Studio.

Conversations are the center of the application. More than 300 pre-configured assistants ship with it, you can define your own, and a single prompt can go to several models at once so their answers are compared directly.

Around the chat sits a working set of tools.

• Document handling: text, images, Office files and PDFs are processed inside the client.
• MCP servers: Model Context Protocol support extends what the assistants can reach.
• Rendering: complete Markdown, Mermaid diagrams and syntax-highlighted code appear inline.
• Search and topics: global search and a topic management system keep long histories navigable.
• WebDAV backup: files and conversation data sync to storage that you control.

Themes cover light, dark and a transparent window, with a community gallery of alternatives. The roadmap names notes and collections, OCR, text to speech, a plugin system and mobile editions, so several of the things being discussed around the project have not shipped yet.

NanoClaw came out of a refusal. Its author would not hand complex software he did not understand full access to his life, so each agent here runs in its own Linux container and sees only what you explicitly mount, rather than sitting behind application-level allowlists in one shared process.

A single Node host acts as the router. A message arrives from a channel, gets written to a per-session SQLite file, and wakes the container; the agent writes back to a second SQLite file that the host polls and delivers. Two files per session with exactly one writer each removes any need for IPC or stdin piping.

The project takes a firm line on how it grows.

• Skills over features: channel adapters and alternative model providers live on separate branches, copied into your fork on demand.
• No configuration files: you change behavior by asking Claude Code to edit the code, which is small enough to review.
• Multi-channel: WhatsApp, Telegram, Discord, Slack, Teams, iMessage, Matrix, Google Chat, Webex, Linear, GitHub and email are all installable.
• Agent templates: a reusable bundle of instructions, tools and skills stamps out a ready-to-run agent carrying no secrets.
• Nothing phones home: only anonymous setup diagnostics leave the machine, and one environment variable turns those off.

One shell script installs Node, pnpm and Docker if missing, registers your credential, builds the agent container and pairs your first channel. It needs macOS or Linux, Windows through WSL2, Node 22 and Docker.

LibreChat puts a single chat interface in front of many model providers, among them OpenAI, Azure, Anthropic, AWS Bedrock, Google, Vertex AI, Ollama, Mistral, Groq, Cohere, OpenRouter and DeepSeek. Endpoints and presets can be switched mid-conversation, and messages can be edited, resubmitted, forked or branched instead of abandoned.

Beyond chat, several subsystems make it usable as a working environment.

• Agents: no-code assistants with MCP servers, tools, file search and code execution, shareable with specific users and groups.
• Subagents: focused work is delegated to isolated child runs with their own context windows.
• Code Interpreter: sandboxed execution in Python, Node, Go, C, Java, PHP, Rust and Fortran, with file upload and download.
• Web search: search providers, content scrapers and result rerankers combine to pull context into a conversation.
• Code artifacts: React, HTML and Mermaid content renders inline and exports as SVG or PNG.
• Speech and audio: speech-to-text and text-to-speech through OpenAI, Azure and ElevenLabs.

Recent work has gone into durability. Responses reconnect and resume when a connection drops, the same chat syncs across tabs and devices, agent runs can be interrupted and steered, and human-in-the-loop pauses wait for input or tool approval before carrying on.

Deployment templates exist for several hosting providers, the interface is translated into more than thirty languages, and security defaults include HTTP headers, per-user code interpreter tokens, SAML identity binding and SSRF protection on web tool traffic.

Jan packages open source AI into a desktop application for people who would rather not send every prompt to a hosted service. Models download from HuggingFace and run on the machine in front of you, with cloud providers available when you actually want them.

The app is built with Tauri and bundles a llama.cpp engine, with build variants for CPU, Vulkan, Metal, CUDA and ROCm. Installers exist for Windows, macOS and Linux in deb and AppImage form, and it is also distributed through the Microsoft Store and Flathub.

The core capabilities are deliberately narrow.

• Local models: runs Llama, Gemma, Qwen, GPT-oss and other LLMs pulled straight from HuggingFace.
• Cloud connections: reaches OpenAI, Anthropic, Mistral, Groq, MiniMax and others when a hosted model suits the task better.
• Custom assistants: lets you define specialized assistants for recurring work.
• Local API server: exposes an OpenAI compatible endpoint on port 1337 for other applications to call.
• Model Context Protocol: adds agentic behavior through MCP integration.

Hardware expectations are stated plainly. On macOS 13.6 or later that means 8GB of RAM for 3B models, 16GB for 7B and 32GB for 13B. Building from source needs Node 20, Yarn 4.5.3, Make, Rust and, on Apple silicon, the Metal toolchain, after which a single make target installs dependencies, builds the core and launches the app.

Rather than build chat, retrieval and agent plumbing in house, a team can stand up Onyx and get an application layer for large language models that it hosts itself. Company knowledge arrives through more than 50 indexing connectors or through MCP.

Model choice stays open. The platform works with self hosted runtimes such as Ollama, LiteLLM and vLLM as well as proprietary providers including Anthropic, OpenAI and Gemini.

Several capabilities sit on top of that foundation.

• Agentic RAG: a hybrid index paired with retrieval agents for search and answer quality.
• Deep research: multi step research flows that produce in depth reports.
• Custom agents: agents given their own instructions, knowledge and actions.
• Web search: an in house crawler plus support for Serper, Google PSE, Brave, SearXNG and others.
• Code execution: a sandbox for analysing data, rendering graphs or modifying files.

Deployment runs through Docker, Kubernetes, Helm or Terraform, with a single install command for a quick start. A Lite mode trims the stack to a chat interface under 1GB of memory, while the standard deployment adds the vector and keyword index, background job workers, model inference servers and caching for larger use.

The Community Edition is MIT licensed and covers chat, RAG, agents and actions, with an Enterprise Edition adding single sign on, role based access control, analytics, query history and whitelabeling.

Meant to extend what one person can do, Khoj runs as a personal AI app that scales from a laptop up to a deployment serving a whole company. The gap it closes is the one between what your documents know and what the internet knows.

It talks to whichever model you point it at, local or hosted, naming llama3, qwen, gemma, mistral, gpt, claude, gemini and deepseek among them. Access is not tied to one window either: the same assistant is reachable from a browser, Obsidian, Emacs, a desktop app, a phone or WhatsApp.

The features cluster around finding, asking and automating.

• Document grounding: answers drawn from images, PDFs, Markdown, org mode, Word and Notion files.
• Semantic search: relevant documents surfaced quickly rather than by exact keyword.
• Custom agents: agents given their own knowledge, persona, chat model and tools.
• Automations: repetitive research handled on a schedule, delivering personal newsletters and notifications to your inbox.
• Generation: images created from prompts, messages played back, replies spoken aloud.

Khoj is open source and self hostable, with setup documented for running it privately on your own computer, and a hosted app is available for anyone who would rather skip installation entirely. For organizations, the project is offered as a cloud service, on premises or as a hybrid arrangement.

Kortix, the project developed in the Suna repository, treats a company as something you can clone. The agents, the skills they share, the company memory and every connector are files in a git repo, versioned and diffable, not configuration trapped inside somebody else's product.

Work happens on cloud computers. Each session gets a disposable, isolated Linux sandbox on its own branch, where the agent can install, run and break anything, and only what it commits survives. Nothing reaches the main branch until you approve a change request, so the company improves one reviewed change at a time. Thousands of sandboxes can run in parallel.

The pieces you manage are few, and each one is a file you can read.

• Agents: OpenCode agents with scoped tool access, markdown at the baseline, one per role or task, able to rewrite themselves.
• Skills: reusable know how that encodes how your company does a job, written once and shared into every session.
• Connectors: more than 3,000 apps in a click, plus MCP, OpenAPI, GraphQL and raw HTTP, with credentials brokered server side and never entering the sandbox.
• Channels and triggers: a Slack app starts sessions where your team works, while cron schedules and signed webhooks start them automatically.
• Secrets: encrypted at rest, granted per agent, and injected into the sandbox as real environment values at runtime.

Any provider works with your own API keys. Kortix runs from Docker images on a laptop, a VPS, your own VPC or an on-prem network, and the CLI switches between your hosts and the cloud.

Scira answers a question by researching it. You type a question, upload a PDF or paste a URL, and the agent breaks the request into sub-tasks, searches live sources, cross-checks the evidence and returns an answer whose claims each carry an inline citation you can click and audit.

The application is built on Next.js with Tailwind CSS and shadcn/ui, and routes model calls through the Vercel AI SDK, so it runs against xAI, OpenAI, Anthropic, Google, Mistral, DeepSeek and many other providers. Retrieval comes from Exa, Firecrawl, Parallel and Tavily, with Upstash for rate limiting and Drizzle ORM over the database.

Seventeen search modes and twenty-eight tools cover most of what a research session needs.

• Agentic planning: breaks a complex question into steps, picks the models and tools for each, then runs the workflow end to end.
• Grounded retrieval: every answer ships with citations, so the evidence stays auditable rather than implied.
• Specialist modes: academic papers, X posts, Reddit threads, GitHub repositories, stock and crypto data, YouTube transcripts and more.
• Code interpreter: writes and executes Python in a sandboxed Daytona environment and generates charts from the result.
• Lookouts: schedules recurring agents that watch a topic, track changes and email you updates.

Self-hosting runs through Docker Compose or a plain Docker build, and needs API keys for whichever providers you want. The AGPL-3.0 license means bringing your own models and wiring in custom tools is expected rather than tolerated.

Morphic is an AI-powered search engine with a generative user interface. Rather than returning a wall of markdown, it streams a JSON spec that renders inline components, source-credited images, grids and headings, alongside grounded answers that cite where they came from.

It runs on whichever models and search backends you point it at. A model selector detects available providers, covering OpenAI, Anthropic, Google, Ollama, the Vercel AI Gateway and any OpenAI-compatible endpoint, while search can come from Tavily, SearXNG, Brave or Exa.

The application around the answer engine handles what a search tool needs to be usable day to day.

• Search modes: Quick and Adaptive, chosen per query depending on how much work an answer deserves.
• Chat history: conversations stored in PostgreSQL rather than kept only in the browser.
• Sharing: results given a unique link so a colleague can open the same answer.
• Authentication: Supabase Auth for accounts, with a guest mode for anonymous use.
• File upload: documents attached to a search once the feature is configured.

The quickest path is Docker Compose, which starts PostgreSQL, Redis, SearXNG and Morphic together, so no separate search API key is required to get going. Local development uses Bun, and a one-click deploy to Vercel is available.

It suits anyone who wants a private answer engine pointed at their own models and search providers, running on a laptop or a single server under the Apache 2.0 license.

5ire speaks to OpenAI, Azure, Anthropic, Google, Mistral, Doubao, Grok, DeepSeek and Ollama from one desktop window, and doubles as a client for the Model Context Protocol. That second part is what separates it from a chat box, because the assistant can act on your machine instead of only answering.

MCP standardizes how applications give context to language models, much as one connector standardizes plugging in peripherals. Through MCP servers, 5ire reaches the file system, system information, databases and remote data. A community-run directory named MCPSvr lists servers to install and gives authors a route to share their own.

The rest of the application is built around keeping your own material close.

• Local knowledge base: the bge-m3 embedding model parses and vectorizes docx, xlsx, pptx, pdf, txt and csv files for retrieval-augmented generation on your machine.
• Usage analytics: API usage and spending are tracked so provider costs stay visible.
• Prompts library: reusable prompts support variables for different situations.
• Bookmarks: saved conversation content survives even when the original messages are deleted.
• Quick search: keyword search runs across every conversation at once.

Turning on the tools feature needs Python, Node.js and the uv package manager first, since together they form the runtime environment for MCP servers; that step can wait until you need it. Because 5ire uses native dependencies it must be packaged on the target platform, and macOS builds need Apple notarization credentials to avoid security alerts.

Lumo is the confidential AI chat assistant from Proton, the company behind Proton Mail and Proton VPN. Mainstream assistants keep chat logs that can be read by the provider, used for training or handed to a third party. Lumo removes that exposure rather than promising not to look.

All conversations with Lumo are stored with zero-access encryption, so no one, not even Proton, can access them, and they are only accessible on your devices. Proton does not log chats, never uses the data to train AI models and cannot share it with third parties. The service is European and GDPR compliant, the company is based in Geneva, and Lumo's code is fully open source, so anyone can verify that it is private and secure.

The assistant itself does the ordinary work you would expect.

• Web search: current information retrieved and folded into an answer.
• Image generation: descriptions turned into images in seconds.
• Proton Drive files: files and folders linked from Drive and worked with in a chat.
• Projects and custom Lumos: saved contexts and tailored assistants on the paid tier.
• Guest access over Tor: anonymous use with no account at all.

Lumo runs as a web app and as iOS and Android apps. The free tier limits messages, history, image generation and use of the strongest model to one project, and Lumo Plus lifts those caps. The source lives in Proton's WebClients monorepo, beside Mail, Calendar, Drive and Pass, under version 3 of the GNU General Public License.

Fullmoon is a chat client for language models that never leave the device. Nothing is uploaded, no account is needed, and it keeps working when the network does not, which is the entire reason to install it rather than talk to a hosted assistant.

It is built on MLX Swift, Apple's array framework for machine learning research on Apple silicon, and draws through Metal 3. Builds run on iOS, iPadOS, macOS and visionOS, and chat history is stored locally on the device.

What you get is a short list of models and a few controls around them.

• Llama 3.2 1B Instruct: a 4-bit build of about 0.7 GB, the smallest option.
• Llama 3.2 3B Instruct: a 4-bit build of about 1.8 GB.
• DeepSeek R1 Distill Qwen 1.5B: available as a 1.0 GB 4-bit build or a 1.9 GB 8-bit build.
• Appearance: theme, fonts and the system prompt are all adjustable.
• Shortcuts: call a local model from the Shortcuts app and pass its output into other actions.

Fullmoon comes from Mainframe and reaches users through the App Store, with a TestFlight build carrying the newest features and models, and the iOS source published on GitHub. Apple silicon is the hard requirement, so older Intel hardware is out. Storage is the other practical limit, since every model is downloaded onto the device and the largest of them runs close to two gigabytes.

Switching between model providers usually means switching between chat apps. Zola is a single open-source interface that talks to all of them, so a conversation can move from a hosted frontier model to something running on your own machine without leaving the window.

It is a Next.js application styled with Tailwind CSS and assembled from shadcn/ui, prompt-kit and motion-primitives, with the Vercel AI SDK handling model integration and Supabase providing auth and storage. Cloning the repository, installing dependencies and setting one API key is enough for a working instance.

The feature set stays close to what a chat client actually needs.

• Multi-model support: OpenAI, Mistral, Claude, Gemini and Ollama are all addressable from the same interface.
• Bring your own key: OpenRouter lets you supply your own credentials instead of routing through a vendor account.
• Local models: Ollama installations are detected automatically, so models you already pulled show up without configuration.
• Customization: user system prompts, several layout options, and light or dark themes.
• File uploads: attachments work once auth and storage are configured.

Deployment runs from a dev server on a laptop to a Docker Compose file bundled with Ollama, or a one-click push to Vercel. The code is Apache 2.0 licensed. Full MCP support is listed as a work in progress and the project calls itself a beta whose codebase is still moving, so treat it as something to run and follow rather than something to build a business on.