A self-hosted Nextcloud AI Assistant is the Assistant app plus a backend you choose: either Nextcloud's own llm2 app, which needs "a NVIDIA GPU with at least 8GB VRAM", or the "OpenAI and LocalAI integration" app pointed at any OpenAI-compatible endpoint, for which Nextcloud's documentation lists vLLM at http://localhost:8000/v1 and Ollama at http://localhost:11434/v1. Put that endpoint on a MassiveGRID GPU dedicated server, 24 GB for $449.99 or 96 GB for $1,656.15 per month, and summaries, chat and Context Chat answers are generated on hardware that serves only you.
This applies to a Nextcloud you administer, because it needs the administration settings and the right to install apps. Everything quoted from Nextcloud comes from its administration manual and the integration app's repository as read on 16 November 2026. The GPU server is assumed to run Ubuntu 24.04 LTS with the NVIDIA driver and Docker in place, as set up in the first-hour GPU server guide.
How does Nextcloud Assistant get its AI?
Nextcloud separates the interface from the model. The manual calls the Assistant "the primary graphical user interface" for AI features and says "you will need additional apps that act as backends to provide the actual implementation".
For text, the manual names three backend apps: llm2, the "OpenAI and LocalAI integration" app (integration_openai) and integration_watsonx. Two of them keep processing on your own hardware:
| llm2 (Local large language model) | OpenAI and LocalAI integration, pointed at your own endpoint | |
|---|---|---|
| What it is | An External App that runs gguf models with llama.cpp | A connector to "any service that implements an API similar enough to the OpenAI API" |
| Stated requirements | AppAPI v3.1.0 or higher, CUDA >= v12.4 on the host, "a NVIDIA GPU with at least 8GB VRAM", "at least 12GB of system RAM" | A Service URL and an API key; hardware is whatever the model needs |
| Scaling | "It is currently not possible to scale this app"; "a rough capacity of 1000 user requests per hour", a figure Nextcloud says is based on theory | Scales with the endpoint; Nextcloud itself recommends this route for scaling up |
| Nextcloud's caveat | Output quality "will differ depending on which model you use" | "We test the Assistant tasks that this app implements only with OpenAI models and only against the OpenAI API" |
This guide takes the second route, which the llm2 page itself recommends for scale: "hosting a service compatible with the OpenAI API yourself that can be scaled up and connecting nextcloud to it via the integration_openai app". A GPU server running vLLM or Ollama is that service.
Which Nextcloud instances can do this?
You need administrator access: to install apps, to open the "Artificial intelligence" settings and, for Context Chat, to register External Apps through AppAPI.
- A Nextcloud you run yourself, on a VPS, a dedicated server or on premises: yes.
- A dedicated Nextcloud Enterprise instance: this is the hosted case it fits. A dedicated Nextcloud Enterprise instance from MassiveGRID is a single-tenant installation for 50 users or more, so its AI backend can point at a GPU server that is also yours alone. Agree the app installation and the endpoint with our team when planning it.
- The shared Nextcloud Hub plans: do not assume it. They run on a shared platform where you are not the server administrator, so ask sales what is possible before buying a GPU server for it.
For features and data handling against the office-suite assistants, see the Nextcloud AI Assistant vs Gemini vs Copilot comparison; this post is the build.
How do you prepare the endpoint on the GPU server?
Nextcloud needs an HTTPS URL that speaks the OpenAI API and a key. Both model servers below listen on 127.0.0.1 only, and a reverse proxy adds TLS.
Option A: vLLM. vLLM checks an API key itself (--api-key). This is its documented Docker command with our additions: detached mode, a name and restart policy, the port on loopback only, the model, the key and the tool-calling flags that "Chat with tools" and Context Agent rely on (parser openai for gpt-oss, per vLLM's documentation).
export VLLM_API_KEY=$(openssl rand -hex 32); echo "$VLLM_API_KEY"
docker run -d --name vllm --restart unless-stopped --runtime nvidia --gpus all \
-v ~/.cache/huggingface:/root/.cache/huggingface \
--env "HF_TOKEN=$HF_TOKEN" \
-p 127.0.0.1:8000:8000 \
--ipc=host \
vllm/vllm-openai:latest \
--model openai/gpt-oss-20b \
--api-key "$VLLM_API_KEY" \
--enable-auto-tool-choice \
--tool-call-parser openai
Option B: Ollama. It is simpler to run, but its documentation states that a local server ignores the API key a client sends, so the key check must live in the proxy. The n8n and Flowise local LLM guide has the Ollama install and a Caddyfile that rejects requests without your token; use it unchanged.
TLS with Caddy. Point a DNS record such as ai.example.com at the server and install Caddy from its Debian and Ubuntu repository. It obtains the certificate automatically when ports 80 and 443 are reachable. For vLLM, which checks the key itself, /etc/caddy/Caddyfile is:
ai.example.com {
reverse_proxy 127.0.0.1:8000
}
Verify from the Nextcloud server, not from your laptop, so you also test the network path. The first command must print 401 and the second a JSON list containing your model:
curl -s -o /dev/null -w "%{http_code}\n" https://ai.example.com/v1/models
curl -s https://ai.example.com/v1/models -H "Authorization: Bearer YOUR_KEY"
Then tighten the firewall on the GPU server: allow port 443 only from your Nextcloud server's address and leave port 80 open so Caddy can renew the certificate. The vLLM guide for 96 GB cards goes deeper on the server side.
How do you connect Nextcloud to the endpoint?
1. Install the two apps. From the Apps page, or on the Nextcloud server's command line (the first line is from the manual, the second uses the app id the manual gives):
sudo -E -u www-data php occ app:enable assistant
sudo -E -u www-data php occ app:install integration_openai
2. Add the service. Open Administration settings, "Artificial intelligence", and find the "OpenAI and LocalAI integration" section. The app's documentation describes the step as: add a service, "set its Service URL to the OpenAI-compatible base URL (the part before /chat/completions, /models, ...) and enter the API key. The models are then listed from the service's /models endpoint". For this setup the Service URL is https://ai.example.com/v1.
3. Select the models to expose. According to the app's README, "every selected model is registered as its own set of providers, named after the model", covering chat, chat with tools, summaries, headlines, topics, reformulation, proofreading and translation.
4. Assign providers to tasks. Still under "Artificial intelligence", choose your model as the provider for each text task type, and disable task types you do not want.
5. Speed up task pickup. The manual: "Most AI tasks will be run as part of the background job system in Nextcloud which only runs jobs every 5 minutes by default." The fix is a set of workers: run the following "preferably 4 or more times" in screen or tmux, or as the systemd service the manual documents:
set -e; while true; do sudo -E -u www-data php occ taskprocessing:worker -v -t 60; done
Before Nextcloud 32.0.7 the command was background-job:worker.
Verify. Ask the Assistant for a summary and watch both ends: occ taskprocessing:task:list on the Nextcloud server shows the task, and docker logs vllm or journalctl -u ollama on the GPU server shows the request.
What does Context Chat need?
Context Chat answers questions from your own files. It is "an ensemble of two apps", context_chat (PHP) and context_chat_backend (a Python External App), and it does not bring its own language model: it "will use the configured text-to-text task processing provider", which is the endpoint you have just connected. Its stated requirements:
- "Minimal Nextcloud version: 32".
- "We currently support NVIDIA GPUs, AMD GPUs (via Vulkan) and x86_64 CPUs", with a "CPU that supports AVX and AVX2 instruction" and "CUDA >= v12.8 on your host system if NVIDIA GPUs are used".
- GPU setup: "A GPU with at least 2GB VRAM" and "At least 8GB of system RAM". CPU setup: "At least 12GB of system RAM", and "4+ cores for the embedding model".
- "A dedicated machine is recommended."
Install order from the manual: the Assistant, a Deploy Daemon in the AppAPI settings, the two apps, a text-to-text provider, then the background workers.
occ app_api:app:register context_chat_backend
occ app:enable context_chat
Two planning points come straight from the documentation:
- Disk. "All the users' textual data is duplicated, chunked and stored on disk in this vector DB along with semantic embedding vectors."
- Embeddings can use the GPU server too. The embedding service "should be able to serve an OpenAI-compatible API" and is set with
CC_EM_BASE_URL(plusCC_EM_MODEL_NAMEandCC_EM_APIKEY) in the Deploy Options. But "the embedding model cannot be changed after installing the app" without a full reinstall, so decide before the first indexing run, which the manual warns "can take a long time".
Three documented limits to tell your users about: Context Chat "does not follow" rules set with the files_accesscontrol app; "files larger than 100MB are not supported"; and "multi-tenant installation is not supported". The self-hosted RAG stack walkthrough explains the retrieval pattern underneath.
Which model and which server?
Nextcloud says the text tasks were "tested with OpenAI GPT-3.5 and Llama 3.1 8B" and "may work with other models, but we can give no guarantees". So verify each task type you plan to offer before rolling out. Sizes are the default tags on ollama.com on 16 November 2026.
| Model (Ollama tag) | Download | Why consider it | Server |
|---|---|---|---|
| llama3.1:8b | 4.9 GB | The open model Nextcloud names as tested | RTX PRO 4000, 24 GB, $449.99/mo |
| gpt-oss:20b | 14 GB | Apache 2.0; documented tool-call parser in vLLM for Chat with tools | RTX PRO 4000 |
| llama3.3:70b | 43 GB | Larger model for longer documents and harder questions | RTX PRO 6000, 96 GB, $1,656.15/mo |
| gpt-oss:120b | 65 GB | Apache 2.0; largest of this list that fits one card | RTX PRO 6000 |
The download is the floor: context and concurrent requests take memory on top, and four or more workers mean parallel requests. On the 24 GB card that argues for the 5 GB to 14 GB models; the 96 GB card holds a 43 GB model with an embedding model beside it. We publish no throughput figures; measure with your own users' tasks.
What stays private, and what does not change?
With this setup, a prompt travels from the user's browser to your Nextcloud server, from there over TLS to your GPU server, and back. For Context Chat, document chunks and embeddings stay in the backend's vector database, and the excerpts that support an answer go to the same endpoint. No third-party AI service receives prompts or files. Nextcloud's own overview table gives the Ollama route for text processing a yellow Ethical AI rating and a "Yes" under keeping data on premises.
What it does not do:
- It does not make you compliant by itself. Access rights, logging, retention and the Context Chat limits above are still yours to manage.
- It does not add redundancy. A dedicated GPU server is a single machine. If it is down, AI tasks queue or fail while the rest of Nextcloud carries on. Keep the Caddyfile and run command documented so the endpoint can be rebuilt quickly.
- It does not settle location. The server is hosted in an ISO 27001 certified data center; if the country matters for your data, ask sales which data center a server will be delivered in before ordering.
The private AI hosting page describes the same pattern for other applications.
What does it cost, and when is a hosted assistant the better choice?
The GPU server is a flat cost shared by every user. Microsoft 365 Copilot is listed at $30.00 per user per month paid yearly as an add-on to a qualifying Microsoft 365 licence (Microsoft's pricing page, checked on 16 November 2026). The arithmetic: $449.99 a month equals 15 Copilot seats and $1,656.15 equals 56. For a dedicated instance at its 50-user minimum, 50 x $30 = $1,500 a month for Copilot seats, against $449.99 for the 24 GB server, which is $9.00 per user. The 96 GB server at $1,656.15 is $33.12 per user at 50 users and drops below $30 per user from 56 users. Add the one-time setup fee ($346.48 or $1,656.15) to the first month.
That comparison is about price only, and it flatters the server. Copilot and Gemini run frontier models that an open model on one card will not match on hard reasoning, they are wired deeply into their own suites, and nobody on your team has to run them. For a small team that lives in one of those suites, the hosted assistant is the better fit. The self-hosted backend earns its place when control over where data is processed has to extend to AI, when enough users share the flat cost, or when Context Chat must work over documents that cannot go to an outside API.
What goes wrong?
- Tasks take minutes. No workers are running, so tasks wait for the 5-minute background job. Start the
taskprocessing:workerloops. - No models appear after adding the service. The Service URL is missing
/v1, the key is wrong, or the Nextcloud server cannot reach the GPU server. Repeat the curl test from the Nextcloud host. - Summaries work but "Chat with tools" or Context Agent fails. The endpoint was started without tool calling. On vLLM add
--enable-auto-tool-choiceand the right--tool-call-parser; on Ollama choose a model that supports tools. - Context Chat's container restarts during indexing. The manual points to RAM or storage filling up, or a CPU without AVX; check with
grep -i avx /proc/cpuinfo.
Frequently Asked Questions
Can Nextcloud Assistant use a local LLM instead of OpenAI?
Yes. Install the "OpenAI and LocalAI integration" app and set its Service URL to your own OpenAI-compatible endpoint; its documentation lists Ollama, vLLM, LocalAI and llama.cpp among self-hosted options. Alternatively the llm2 app runs gguf models locally on an NVIDIA GPU with at least 8 GB of vRAM.
How much GPU memory does Nextcloud Context Chat need?
The Context Chat backend itself states "a GPU with at least 2GB VRAM" and at least 8 GB of system RAM, or 12 GB of RAM on CPU. The language model is separate: Context Chat uses your configured text provider, so add whatever your model needs.
Why is the Nextcloud Assistant slow to answer?
By default AI tasks are picked up by the background job system, which runs every 5 minutes. Nextcloud's manual recommends running four or more occ taskprocessing:worker processes so tasks start as soon as they are scheduled.
Can I use my own GPU backend with a MassiveGRID Nextcloud plan?
It fits a Nextcloud you administer, such as a dedicated Nextcloud Enterprise instance, where the AI apps and the endpoint can be configured for your instance alone. The shared Hub plans run on a shared platform, so ask sales what is possible there before ordering a GPU server.
A private AI backend for your Nextcloud
MassiveGRID GPU dedicated servers: RTX PRO 4000 Blackwell with 24 GB for $449.99 per month or RTX PRO 6000 Blackwell with 96 GB for $1,656.15 per month, bare metal with root access in an ISO 27001 certified data center, one dedicated IPv4 and a 1 Gbps port with unlimited traffic. One-time setup fee applies.
See Private AI HostingFurther Reading
- Nextcloud admin manual: Nextcloud Assistant (backends per task type, occ commands)
- Nextcloud admin manual: AI as a Service and the OpenAI integration app
- Nextcloud admin manual: Local large language model (llm2) requirements and scaling
- Nextcloud admin manual: Context Chat requirements, scaling and limitations
- Nextcloud admin manual: AI overview (ratings, task pickup speed and workers)
- integration_openai: supported providers and service URLs (vLLM, Ollama)
- Ollama docs: OpenAI compatibility
- vLLM docs: tool calling flags and parsers
- Microsoft 365 Copilot enterprise pricing