AnythingLLM Self-Hosted

IntermediateAi Agents

A private AI workspace for your team: chat with your documents and run agents on your own server, with a local model or the one you choose.

Published 12 October 2026 · Last updated 12 October 2026

Core Tools
Docker
Docker
AnythingLLM
AnythingLLM
Database
SQLite
PostgreSQL
Model Inference
Ollama
LM Studio
llama.cpp
vLLM
Hosting
Hetzner
Hostinger
DigitalOcean
Railway
Render
+2
Reverse Proxy
Traefik
Caddy
NGINX
Self-Hosted PaaS
Coolify
Dokploy

About AnythingLLM Self-Hosted

AnythingLLM is a self-hosted AI workspace built around retrieval: each workspace gets its own uploaded documents, vector settings, and model, so one deployment can hold separate knowledge bases for different teams or clients, with chat, agents, and an embeddable chat widget on top. The Docker version is the multi-user one: the free desktop app serves a single person, and AnythingLLM Cloud hosts a private instance for $50 a month and up. Self-hosting it is free under the MIT license and keeps documents, conversations, and stored provider keys on infrastructure you administer, and with a local model nothing has to leave your network at all.

The official image runs one container on port 3001 with a storage directory mounted from the host. That directory holds everything: the SQLite database with users, workspaces, and chats, the built-in LanceDB vector store, uploaded documents, the cached embedding model, agent skills, and the .env file with settings and keys. A PostgreSQL build of the image stores the same data in a database you run instead. AnythingLLM itself needs 2 GB of RAM and a 2-core CPU with AVX2, which the built-in vector store requires, so a small server is enough for the app.

The model is the heavy part. The stack defaults to a local runtime, Ollama, and AnythingLLM's docs advise running it on a separate machine with a graphics card when the app server has none, since a model needs many times the memory AnythingLLM does. The container reaches it by address, using host.docker.internal when both run on one machine, and the same settings page switches the system or a single workspace to a hosted model. Watch the token limit: AnythingLLM uses up to 16,384 tokens of an Ollama model's context unless you set it higher, and only 4,096 for a runtime added through its Generic OpenAI provider, which cuts long documents short.

A fresh instance is open to anyone who can reach it. Turn on password protection or multi-user mode before publishing it, then put a reverse proxy with TLS in front of port 3001, or install it from a self-hosted PaaS template that brings its own proxy and generates the secrets. The official cloud templates serve plain HTTP on port 3001, so they need the same steps. Anonymous telemetry is on by default and turns off with one setting. A tunnel is the alternative when nothing on the server may accept inbound traffic.

Key Features

  • ✓AnythingLLM in one official Docker container, with its database, built-in vector store, and documents in one storage directory
  • ✓Workspaces with their own documents, vector settings, and model, for separate knowledge bases in one deployment
  • ✓A local model runtime by default (Ollama, LM Studio, llama.cpp, or vLLM), switchable per workspace
  • ✓Multi-user mode with admin, manager, and default roles
  • ✓Agents with built-in skills and MCP server support, plus an embeddable chat widget and a developer API
  • ✓MIT-licensed, with no paid edition gating features

When to Use AnythingLLM Self-Hosted

  • →A private ChatGPT-style assistant for a team, answering from the company's own documents
  • →Separate knowledge bases per client or department in one deployment
  • →Chat over sensitive documents with a local model, so nothing leaves your network
  • →A document-aware chat widget embedded in an internal site
  • →Trying local and hosted models side by side on the same documents

Pros

  • One container and a small server run the app; the model is a separate, swappable piece
  • MIT-licensed with no feature gating, branding condition, or user-count threshold
  • Workspace isolation makes several knowledge bases in one deployment straightforward
  • Works with local runtimes and hosted providers alike, set per workspace

Cons

  • A fresh instance is open to anyone who reaches it until a password or multi-user mode is set
  • A local model needs a graphics card or far more memory than the app, usually a second machine
  • The CPU must support AVX2, or the built-in vector store fails to start
  • Multi-user mode can't be turned back into single-user mode once enabled

Database Options for AnythingLLM Self-Hosted

SQLite

AnythingLLM Self-Hosted with SQLite

The default in the standard image: one file in the storage directory holding users, workspaces, chats, and settings, with nothing else to run. It suits a single server well, and a backup is a copy of the storage directory. It also means one container per deployment, since SQLite can't be shared between instances.

PostgreSQL

AnythingLLM Self-Hosted with PostgreSQL

Through AnythingLLM's pg image, which stores all of its data in a PostgreSQL database set with DATABASE_URL and uses pgvector there for document vectors by default. The database needs the pgvector extension installed. Pick it when the team already backs up and operates PostgreSQL, or wants the data in a managed database. The choice is made at install, since moving from the SQLite file later means a data migration.

These are highlighted picks. To see all the tools, check the Databases category.

Model Inference Options for AnythingLLM Self-Hosted

Ollama

AnythingLLM Self-Hosted with Ollama

The default and AnythingLLM's most common local runtime: select Ollama as the provider with its base URL, http://host.docker.internal:11434 when both run on one machine or the GPU machine's address otherwise, and pick a pulled model. AnythingLLM reads each model's context length from Ollama and uses up to 16,384 tokens of it, so raise the token limit for long documents when the graphics card has memory to spare, and raise the response timeout from its five-minute default on slow hardware. Ollama can also serve the embedding model in place of the built-in one.

LM Studio

AnythingLLM Self-Hosted with LM Studio

A desktop app with a local server on port 1234 that AnythingLLM connects to through its LM Studio provider, with an optional auth token. It fits a team whose model runs on a workstation or a Mac with plenty of memory on the same network, and it lets someone compare models in a graphical browser before settling on one. A desktop app is the wrong home for a model the whole team depends on all day.

llama.cpp

AnythingLLM Self-Hosted with llama.cpp

The lightest runtime: llama.cpp's server exposes an OpenAI-compatible API that AnythingLLM reaches through its Generic OpenAI provider, with the /v1 address, the model name, and the token limit, which falls back to 4,096 when left empty. It runs one model on a CPU or a modest graphics card with very little overhead, and there is no model library or download manager, so you fetch the GGUF file yourself.

vLLM

AnythingLLM Self-Hosted with vLLM

For a GPU server that answers many people at once: AnythingLLM's Generic OpenAI provider points at vLLM's /v1 address with its API key. Batched serving keeps response times steady when a whole team asks questions at the same time, which single-user runtimes don't. vLLM serves one model per server; vLLM Inference Server is a stack of its own.

These are highlighted picks. To see all the tools, check the AI Runtime & Serving category.

Hosting Options for AnythingLLM Self-Hosted

Hetzner

Deploy AnythingLLM Self-Hosted on Hetzner

The default. A shared-vCPU server with 2 vCPUs and 4 GB of RAM costs about €19 a month and runs AnythingLLM with room for its built-in embedder and vector store; its x86 CPUs support the AVX2 instructions the vector store needs. That server can run only small models slowly on its CPU, so point AnythingLLM at Ollama on a machine with a graphics card, such as one you own or Hetzner's GPU servers from about €214 a month. Install Docker, mount the storage directory, and set a password before publishing anything.

Hostinger

Deploy AnythingLLM Self-Hosted on Hostinger

The budget entry. The KVM 2 plan has 2 vCPUs, 8 GB of RAM, and 100 GB of NVMe at $8.99 a month on a two-year term, $14.99 at the standard rate, double what AnythingLLM needs, and enough to try a small quantized model on the CPU next to it, slowly. The cheaper KVM 1 has a single vCPU, below the 2-core minimum. Root access is full and the panel adds weekly backups; TLS and the password are your job.

DigitalOcean

Deploy AnythingLLM Self-Hosted on DigitalOcean

AnythingLLM maintains a Terraform template that creates a Droplet running the container, served over plain HTTP on port 3001, so a password and a proxy for HTTPS still come after it. The template's default is the 2 GB Droplet at $18 a month, AnythingLLM's floor; the 4 GB Basic Droplet with 2 vCPUs at $24 covers the app with headroom. DigitalOcean also rents GPU Droplets, which can host the model runtime near the app when a team has no hardware of its own.

Railway

Deploy AnythingLLM Self-Hosted on Railway

A container platform with a one-click template linked from AnythingLLM's README, using the Railway build of the image. TLS ends at the platform, so the reverse proxy or PaaS choice doesn't apply, but the instance still needs a password before it is shared. Attach a volume at the storage directory, or the database and documents go with each redeploy. Memory is billed at about $10 per GB a month on top of the $5 Hobby plan, so the app lands around $25. There is no GPU here, so the model runs elsewhere or is a hosted one.

Render

Deploy AnythingLLM Self-Hosted on Render

A container platform with a Deploy to Render button in AnythingLLM's README, built from the render branch and the Render build of the image. AnythingLLM's 2 GB floor means the Standard instance, $25 a month, plus a persistent disk for the storage directory, which also keeps the service to a single instance. TLS ends at the platform, so the reverse proxy or PaaS choice doesn't apply. Render has no GPUs, so pair it with a remote runtime or a hosted model.

Amazon Web Services

Deploy AnythingLLM Self-Hosted on Amazon Web Services

AnythingLLM's own CloudFormation template creates one EC2 instance with a 10 GiB volume and serves the app over plain HTTP on port 3001, so a password, a domain, and HTTPS are still to add. Its default t3.small has 2 GB, AnythingLLM's floor; a t3.medium with 2 vCPUs and 4 GB costs about $30 a month on demand. Bedrock is one of AnythingLLM's model providers, so a team on AWS can keep model calls in the same account, and GPU instances can host a runtime for local models.

Google Cloud Platform

Deploy AnythingLLM Self-Hosted on Google Cloud Platform

AnythingLLM's GCP template creates a Compute Engine VM, but its defaults need changing: an n1-standard-1 has a single vCPU, below the 2-core minimum, it uses Ubuntu 20.04, and it opens no firewall rule for port 3001. Pick a machine with 2 vCPUs and a current image instead, about $25 to $40 a month left on, and allow the port only from your own addresses. Vertex AI is one of AnythingLLM's model providers, so a team on Google Cloud can keep hosted models in the same project.

These are highlighted picks. To see all the tools, check the Hosting & Cloud category.

Reverse Proxy Options for AnythingLLM Self-Hosted

Traefik

AnythingLLM Self-Hosted with Traefik

The family default: it discovers the AnythingLLM container from Docker labels and renews certificates itself, with one router for port 3001. Raise the response timeouts, because streamed answers from a slow local model can run for minutes and a proxy that cuts them breaks the chat, and raise the upload size limit so people can add large documents. Set the password or multi-user mode before the router goes live.

Caddy

AnythingLLM Self-Hosted with Caddy

Automatic HTTPS from one site block that forwards to port 3001, with streamed answers passed through as they arrive and generous default timeouts for slow models. The simplest route from the official cloud templates' plain HTTP to a proper domain with TLS. Turn on password protection or multi-user mode before the address is shared.

NGINX

AnythingLLM Self-Hosted with NGINX

The proxy many servers already run. Turn proxy_buffering off so streamed answers aren't held back, raise proxy_read_timeout past the 60-second default for slow local models, and raise client_max_body_size, whose 1 MB default rejects most document uploads. Forward the Upgrade and Connection headers for the app's websocket connections.

Self-Hosted PaaS Options for AnythingLLM Self-Hosted

Coolify

AnythingLLM Self-Hosted with Coolify

A free, self-hosted deploy platform with an AnythingLLM template in its service library. The template generates the password, the JWT secret, and the signing key and salt, turns telemetry off, and keeps the built-in vector store, so the instance is protected from its first start. It runs the latest image, which changes with almost every commit, so pin a versioned tag. Coolify's own proxy handles the domain and TLS.

Dokploy

AnythingLLM Self-Hosted with Dokploy

Free and self-hosted, with an AnythingLLM template that serves the container on your domain with HTTPS through its Traefik routing and keeps the storage directory on a named volume. Unlike Coolify's, it sets no password or secrets and runs the latest image, so pin a versioned tag and set a password or multi-user mode at the first visit, before sharing the address. Domains and TLS come with the platform, so no separate reverse proxy is added next to it.

AnythingLLM Self-Hosted Add-ons

Each addition below extends this stack with a capability the base stack works fine without. None are required: include the ones your product actually needs when building this stack, and skip the rest.

Vector Database Add-ons

Add a vector database when the agent needs to find documents, notes, or past conversations by meaning instead of exact keywords.

Qdrant

AnythingLLM Self-Hosted with Qdrant

Selected as the vector database in AnythingLLM's settings with a Qdrant URL and API key, as one more container on the server or on Qdrant Cloud's free cluster. It takes vector search out of the app container and filters well on metadata, which helps once workspaces hold many large document sets. Changing the vector database means re-embedding the documents already uploaded.

Chroma

AnythingLLM Self-Hosted with Chroma

A Chroma server, by host and port, or Chroma Cloud with an API key, selected in the same vector database settings. A step up from the built-in store when the team wants the vectors in a service it can inspect and back up on its own. Changing the vector database means re-embedding the documents already uploaded.

Weaviate

AnythingLLM Self-Hosted with Weaviate

A Weaviate server or Weaviate Cloud cluster, selected with its endpoint and API key. Its hybrid keyword and vector search and native multi-tenancy suit deployments with many workspaces and large collections. Changing the vector database means re-embedding the documents already uploaded.

PostgreSQL

AnythingLLM Self-Hosted with PostgreSQL with pgvector

Vectors in a PostgreSQL database with the pgvector extension, set with a connection string. It is the default vector store of the pg image, so a deployment on PostgreSQL keeps users, chats, and vectors in one database with one backup. Changing the vector database means re-embedding the documents already uploaded.

Model Aggregator Add-ons

Add a model aggregator when you want one API key and one bill for models from many providers, with automatic fallback when one of them is down, instead of setting up each provider separately.

OpenRouter

AnythingLLM Self-Hosted with OpenRouter

One of AnythingLLM's built-in providers: one key and one prepaid balance for hundreds of hosted models, chosen per workspace, with an automatic router option. Useful for comparing models on the same documents without an account at each provider. Models are billed at the providers' prices, with a 5.5% fee when you buy credits.

LiteLLM

AnythingLLM Self-Hosted with LiteLLM

AnythingLLM's LiteLLM provider points at a gateway you host, which holds the provider keys, enforces budgets and rate limits per key, and falls back between providers, so the keys don't sit in AnythingLLM's own .env file. It suits a company that already routes its model traffic through one place. LiteLLM Self-Hosted is a stack of its own.

These are highlighted picks. To see all the tools, check the AI Model Aggregators category.

Tunnel Add-ons

Add a tunnel when you're self-hosting without a static IP or can't open inbound ports — a home server, a VPS behind restrictive network policies, or anywhere a reverse proxy alone can't reach the internet.

Cloudflare Tunnel

AnythingLLM Self-Hosted with Cloudflare Tunnel

A public HTTPS address through an outbound-only connection, pointed at port 3001, so the team reaches AnythingLLM while no inbound port is open on the server. Free, with Cloudflare Access in front if it should sit behind your company login on top of AnythingLLM's own. A request with no answer within about 125 seconds fails with a 524 on non-Enterprise plans, which matters with slow local models, so keep answers streaming. A stable hostname needs a domain on Cloudflare.

ngrok

AnythingLLM Self-Hosted with ngrok

The quick-start tunnel for showing AnythingLLM running on a workstation to someone else: one command gives port 3001 a public HTTPS address with no domain needed. The free plan includes three endpoints, 1 GB of transfer, 20,000 requests, and an interstitial page on browser visits, so it is a trial route, not the team's address. Paid plans start at $10 a month.

LLM Add-ons

Add a language model when the app needs an AI feature, such as summarising, classifying, drafting text, or answering questions, called through the provider's API with no other new infrastructure.

Claude

AnythingLLM Self-Hosted with Claude

A hosted model for when local hardware isn't enough: set Anthropic as the provider with an API key, for the whole instance or just one workspace, since AnythingLLM picks the model per workspace. Prompt caching is a single setting and cuts the cost of the instructions resent with every message. The prompts and the document passages retrieved for each answer then leave your network, which is the trade against a local model.

OpenAI

AnythingLLM Self-Hosted with OpenAI

GPT models through an OpenAI API key, for the instance or a single workspace, with OpenAI's embedding models available as the embedder too. A reasonable choice for agent workspaces, where tool calling matters more than in plain document chat. Like every hosted provider, the retrieved document passages go to OpenAI with each question.

Google Gemini

AnythingLLM Self-Hosted with Google Gemini

Gemini through a Google AI Studio key, whose rate-limited free tier is enough to try document chat before paying anything. Its long context windows suit workspaces with large documents, and Gemini embedding models can replace the built-in embedder. Retrieved passages leave your network with each question.

These are highlighted picks. To see all the tools, check the LLM category.

Frequently Asked Questions about AnythingLLM Self-Hosted

Why self-host AnythingLLM instead of using AnythingLLM Cloud or the desktop app?

The three cover different cases. The desktop app is free and runs on one person's computer, with no shared workspaces and no multi-user mode. AnythingLLM Cloud is a private hosted instance for $50 a month on Basic or $99 on Pro, and you bring your own model API key. The self-hosted Docker version is free under the MIT license and is the multi-user one you control: documents, chats, and stored keys stay on your server, and it can talk to a model on your own hardware, so a document never has to leave your network. What it costs is running it: the server, the password and TLS, backups, upgrades, and a machine for the model if you use a local one.

What size server does AnythingLLM need?

AnythingLLM's documented minimum is 2 GB of RAM, a 2-core CPU, and 5 GB of storage, and the CPU must support AVX2, because the built-in vector store fails with an "Illegal instruction" error without it. That covers the app, the built-in embedder, and the vector store; disk grows with documents and vectors, and the cloud guide recommends 10 GB. The model is sized separately and is far larger. A small quantized model can run on a CPU slowly, but a team usually needs a machine with a graphics card, either one it owns or a rented GPU server, which is why the docs suggest keeping the model on a separate machine.

Where does state live, and what needs backing up?

In the standard image, everything is in the storage directory mounted from the host: the SQLite database with users, workspaces, chats, and settings, the built-in vector store, uploaded and processed documents, the cached embedding model, agent skills and MCP settings, and the .env file with provider keys and signing secrets. Copy the whole directory with the container stopped, and treat the .env file as a secret, since it holds the API keys entered in the settings pages. With the pg image, the database and vectors move to PostgreSQL, so back it up with pg_dump and keep copying the storage directory for documents and settings. The model runtime holds no AnythingLLM data, only its downloaded models.

How do upgrades work, and is anything behind a paid tier?

Pull a newer image and recreate the container with the same storage mount; database migrations run at startup. Pin a versioned tag such as 1.17.0 instead of latest, which the docs say updates on nearly every commit, and copy the storage directory before each upgrade. Nothing in the self-hosted version is gated: the code is MIT-licensed with no paid edition, branding condition, or user limit. The paid products are the hosted Cloud plans and Enterprise, which adds on-premise deployment, SSO, custom integrations, and a support agreement, priced by quote.

AnythingLLM or Open WebUI for a self-hosted chat interface?

Both give a team a private, ChatGPT-style interface over local or hosted models. Open WebUI is chat-first, with the more mature multi-user administration and the tightest pairing with Ollama, and its license requires keeping its branding above 50 users unless you buy an enterprise license. AnythingLLM is built around document workspaces, each with its own files, vector settings, and model, has a wider choice of vector databases, and is MIT-licensed with no conditions. Pick Open WebUI when the main job is chatting with models, AnythingLLM when the main job is answering from separate document collections. Self-Hosted AI with Ollama and Open WebUI is a stack of its own.

Scores

Popularity4/5

One of the most widely used self-hosted AI chat applications, with a large GitHub following and a desktop app that brought many people to local models. Known well among people building private AI setups, less so among developers at large.

Learning Curve2/5

One container, a guided first-run setup, and a settings page for every provider make the app easy to stand up. The extra steps are protection, since a fresh instance is open, and the model runtime, which brings its own hardware and context-window settings.

Flexibility5/5

Dozens of model providers, local and hosted, a choice of vector databases, two database engines, and per-workspace models and settings, plus agents with MCP and a developer API. It runs on a laptop, a VPS, a container platform, or a cloud VM.

Performance3/5

The app is light and handles a team on a small server, but SQLite keeps it to one container per deployment, and answer speed is set by the model runtime and the hardware under it rather than by AnythingLLM.

Portability5/5

MIT-licensed in a single container, with all data in one storage directory or a standard PostgreSQL database, and model providers swapped in settings. Moving between hosts is copying a directory.

Tools in the AnythingLLM Self-Hosted Stack

DevOps & CI/CD

AI Infrastructure

Database (choose one)

Model Inference (choose one)

Hosting (choose one)

Reverse Proxy or PaaS (choose one)

Reverse Proxy

Self-Hosted PaaS

Add-ons (optional — add any, or none)

Vector Database

Model Aggregator

Tunnel

LLM

AnythingLLM Self-Hosted Pricing

From ~$9/mo Free to start

AnythingLLM is free and MIT-licensed, so the app's cost is a small server: it needs 2 GB of RAM and a 2-core CPU, from about $9 a month on a long-term VPS plan. The model is the larger cost. A local runtime is free software but needs a graphics card, which is hardware you already own or a rented GPU server from about €214 a month, while a hosted model bills per token instead. For comparison, AnythingLLM Cloud starts at $50 a month.

Server (VPS or cloud)$9–30/mo

AnythingLLM needs 2 GB of RAM and a 2-core CPU with AVX2: $8.99 a month for 2 vCPUs and 8 GB at Hostinger on a two-year term, about €19 for 4 GB at Hetzner, $24 at DigitalOcean, $25 for Render's 2 GB instance plus a disk, and about $30 for a 4 GB EC2 instance.

Model runtime (GPU)€0–214+/mo

Ollama, LM Studio, llama.cpp, and vLLM are free software; the cost is the hardware. A machine you already own adds nothing, and a rented dedicated server with a 24 GB graphics card starts at about €214 a month. A hosted model replaces this line with per-token billing.

AnythingLLMFree (MIT)

The self-hosted version has every feature, with no paid edition or user limit. Enterprise support and SSO are sold by quote.

ExposureFree

The reverse proxies, deploy platforms, and tunnels here are free, open-source software or free tiers, and TLS certificates come from Let's Encrypt.

AnythingLLM Self-Hosted System Requirements

source
CPU
2 cores with AVX2 support (required by the built-in vector store)
RAM
2 GB minimum
Disk
5 GB minimum; grows with documents and vectors (10 GB recommended on cloud servers)
OS
Any Linux, macOS, or Windows with Docker; amd64 and arm64 images

Quoted from AnythingLLM's Docker system-requirements page: 2 GB of RAM, a 2-core CPU with AVX2, and 5 GB of storage; AVX2 is the one hard requirement, since LanceDB fails with "Illegal instruction" without it. The repository's Docker guide recommends at least 2 GB of RAM and 10 GB of disk on AWS, GCP, or Azure. These figures size AnythingLLM only: the model runtime is separate and needs far more, usually on a machine with a graphics card, as the docs advise.