Open WebUI alternatieven voor VPS hosting
Zoekt u een alternatief voor Open WebUI op een VPS? Wij vergelijken LibreChat, Hollama en OrionChat op RAM-verbruik, authenticatie en beheer bij een publiek IP-adres.
Welk Open WebUI-alternatief hoort op een VPS
Alternatieven voor Open WebUI worden bijna altijd vergeleken op een laptop, waar RAM goedkoop is en niets luistert op een publiek adres. Een VPS verandert beide feiten, en dat verandert de rangschikking. Open WebUI blijft de juiste standaard zodra een tweede persoon inlogt, omdat het echte gebruikersaccounts en een beheerderspaneel bevat. De lichtere projecten winnen wanneer de interface moet concurreren met het model om de laatste gigabyte aan RAM. De prijs van die winst is authenticatie: die ontbreekt volledig.
Alles hieronder is afkomstig uit de eigen documentatie van elk project, gelezen in augustus 2026, opnieuw gecontroleerd op 20 oktober 2026, en nogmaals gecontroleerd voor Open WebUI, LibreChat, Hollama en OrionChat op 25 oktober 2026. De documentatie van Ollama en de beveiligingsregels van de browser zijn opnieuw gecontroleerd op 29 oktober 2026. De vier assen zijn de assen die pas verschijnen zodra de server bereikbaar is vanaf het internet.
Vier assen die alleen relevant zijn bij een publiek IP-adres
- Geheugen naast het model. De modelserver is het kostbare proces op de machine. Elke megabyte die de interface in beslag neemt, is een megabyte die niet beschikbaar is voor het model.
- Authenticatie. Sommige van deze projecten bevatten gebruikersaccounts en rollen. Andere gaan ervan uit dat zij de enige applicatie op uw laptop zijn en beschikken helemaal niet over een inlogprocedure.
- Remote inference. Een UI die alleen naar
127.0.0.1:11434verwijst, verwacht dat het model op dezelfde machine staat als de interface. Als het model elders wordt geplaatst, is een tunnel of lokale proxy vereist die de lokale poort doorstuurt naar de host van het model. - Onderhoud. Eén container met een SQLite-bestand is een andere taak dan zes containers met MongoDB en een vector-database erachter.
Hoeveel RAM laat het model over voor de interface
De interface is niet het grootste onderdeel op de server. Dat is het model. De gepubliceerde downloadgroottes vormen de ondergrens, omdat de gewichten in het geheugen geladen moeten zijn terwijl het model antwoordt. Het werkelijke geheugengebruik ligt hoger dan de downloadgrootte zodra de context-cache is toegewezen.
De gegevens achter deze grafiek
[
{
"label": "llama3.2:3b",
"download_gb": "2.0"
},
{
"label": "qwen3:4b",
"download_gb": "2.5"
},
{
"label": "gemma3:4b",
"download_gb": "3.4"
},
{
"label": "qwen3:8b",
"download_gb": "5.2"
}
]Dit zijn de cijfers die op 25 oktober 2026 op de bibliotheekpagina's van Ollama stonden. Het zijn gepubliceerde groottes, geen metingen. Op een VPS met 4 GB RAM laat qwen3:4b met 2.5 GB minder dan 1,5 GB over voor het besturingssysteem en alle overige processen. De context-cache snoept hiervan af naarmate een gesprek vordert; daarom is de num_ctx die u instelt net zozeer een beslissing over geheugen als over kwaliteit. qwen3:8b met 5.2 GB past in het geheel niet op die server. Dit is de situatie die in laptop-overzichten nooit wordt behandeld, en het is het punt waarop een chat-interface die enkele honderden megabytes in beslag neemt, bepaalt of het model draait. Als u een server dimensioneert voor iets dat ruim boven deze waarden ligt, laat de berekening voor een 27B model op een VPS zonder GPU zien hoe snel de interface ophoudt de doorslaggevende factor te zijn.
Meet zelf in plaats van te vertrouwen op cijfers uit overzichten, inclusief deze. Voer docker stats --no-stream uit na een uur werkelijk gebruik, niet één minuut nadat de container is gestart, omdat het geheugen dat ertoe doet pas bij het eerste gebruik wordt toegewezen. Ollama geeft de gewichten bovendien vrij na vijf minuten inactiviteit. Een meting die tussen gesprekken door wordt uitgevoerd, onderschat daarom de piekbelasting, en het volgende bericht veroorzaakt opnieuw de volledige belasting, tenzij u het model in het geheugen houdt met keep_alive.
Open WebUI: nog steeds de standaard voor meer dan één gebruiker
Open WebUI draait vanuit één image en slaat de data op in één volume.
docker run -d -p 127.0.0.1:3000:8080 -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:mainHet commando in de README van het project publiceert -p 3000:8080, dat op elke interface luistert. Het 127.0.0.1:-voorvoegsel houdt dit op loopback. Docker waarschuwt dat in releases ouder dan 28.0.0 hosts op hetzelfde L2-segment poorten kunnen bereiken die op localhost zijn gepubliceerd. Gebruik daarom Docker Engine 28.0.0 of nieuwer voordat u op die binding vertrouwt voor isolatie. Op een VPS is dat voorvoegsel belangrijker dan al het andere op de regel, omdat Docker zijn eigen iptables-regels schrijft en een gepubliceerde poort uw ufw deny-regels negeert.
Bereik de pagina via een tunnel of een proxy, beide hieronder beschreven, en maak vervolgens het eerste account aan. Dat account wordt de beheerder. Registratie schakelt zichzelf daarna uit totdat een beheerder New Sign Ups weer inschakelt. Latere aanmeldingen worden aangemaakt met de rol pending, de gedocumenteerde standaard van DEFAULT_USER_ROLE, waardoor een vreemde die de pagina bereikt uw model nog steeds niet kan gebruiken totdat een beheerder hen goedkeurt.
Open WebUI verbruikt meer geheugen dan de onderstaande projecten omdat het meer functionaliteit biedt, en de eigen prestatiepagina benoemt de onderdelen die dit kosten. De standaard embedding-engine laadt een sentence-transformers model in de container. Door RAG_EMBEDDING_ENGINE=ollama in te stellen, wordt die taak overgedragen aan de modelserver die u al draait. AUDIO_STT_ENGINE=web voorkomt het laden van een lokaal speech-to-text model. Op SQLite met DATABASE_POOL_SIZE uitgeschakeld, valt de pool terug op een grote interne omvang en bouwt elke verbinding een eigen page cache en geheugenmap op. Stel daarom op een kleine machine DATABASE_POOL_SIZE=8 en DATABASE_SQLITE_PRAGMA_MMAP_SIZE=0 in. Autocomplete, dat het model om een aanvulling vraagt terwijl een gebruiker nog typt, wordt nu standaard uitgeschakeld geleverd (ENABLE_AUTOCOMPLETE_GENERATION staat standaard op False), dus laat dit zo op een kleine machine.
LibreChat: multi-user, met een stack erachter
git clone https://github.com/danny-avila/LibreChat.git
cd LibreChat
cp .env.example .env
docker compose up -dDe interface reageert op poort 3080. LibreChat is de juiste keuze wanneer u een identiteitssysteem nodig heeft in plaats van alleen een inlogscherm: het documenteert LDAP- en OAuth2-logins, en het standaard compose-bestand definieert ook een beheerderspaneel voor gebruikers, groepen en rollen. Het paneel start niet direct na installatie. Het weigert te starten totdat ADMIN_PANEL_SESSION_SECRET is ingesteld in .env; dit is een vereiste waarde van minimaal 32 tekens zonder standaardwaarde, dus genereer er een met openssl rand -hex 32 als u dit wilt gebruiken. Dat paneel draait als een eigen service, niet binnen het LibreChat-proces, en vereist LibreChat v0.8.5 of later. Die functionaliteit komt beschikbaar met een stack.
De gegevens achter deze grafiek
[
{
"label": "OrionChat",
"containers": 0,
"notes": "static files, served by a web server you already run"
},
{
"label": "Hollama",
"containers": 1,
"notes": "one container serving a browser app"
},
{
"label": "Open WebUI",
"containers": 1,
"notes": "application and SQLite in one image"
},
{
"label": "LibreChat",
"containers": 5,
"notes": "api, MongoDB, Meilisearch, pgvector, RAG API"
}
]Het standaard compose-bestand start 5 services: api, MongoDB, Meilisearch, pgvector, RAG API. Een zesde, het beheerderspaneel, bevindt zich in hetzelfde bestand en sluit zich aan zodra het geheim is ingesteld. Geen van deze is het model. MongoDB en pgvector vereisen elk hun eigen geheugen, en op een machine met 4 GB is dat geheugen dat het model nodig had.
Twee services in het bestand publiceren poorten, en geen van beide mappings specificeert een bind-adres: de API op 3080 en het beheerderspaneel op hostpoort 3000, de standaardwaarde van ADMIN_PANEL_PORT. Beide luisteren daarom op elke interface zodra ze draaien. Poort 3000 is ook de poort die Open WebUI hierboven gebruikt, dus de twee conflicteren op een gedeelde server zodra het paneel wordt ingeschakeld. Koppel beide opnieuw aan 127.0.0.1 in docker-compose.override.yml voordat de stack wordt blootgesteld aan het internet.
Upgrades zijn een git-operatie, en dat is het onderdeel waar mensen fouten maken.
docker compose down
git pull
docker compose pull
docker compose up -dgit pull stopt met een conflict als u het gevolgde bestand docker-compose.yml heeft bewerkt, waarna de upgrade slechts gedeeltelijk is toegepast. Plaats uw wijzigingen in docker-compose.override.yml, dat het project hiervoor aanbiedt, en bewaar geheimen in .env. Beide bestanden worden niet gevolgd door git, dus git pull laat ze ongemoeid.
Wijs LibreChat naar uw eigen modelserver met een aangepast eindpunt in librechat.yaml.
endpoints:
custom:
- name: "Ollama"
apiKey: "ollama"
baseURL: "http://model-host:11434/v1/"
models:
default: ["llama3.2"]
fetch: true
titleConvo: true
titleModel: "current_model"
modelDisplayLabel: "Ollama"Vervang model-host door het adres van de server waarop Ollama draait. Het veld apiKey moet aanwezig zijn, ook al negeert Ollama de waarde ervan, dus een tijdelijke aanduiding volstaat. Als LibreChat in Docker draait en Ollama op dezelfde machine draait, betekent localhost binnen de container de container zelf; gebruik daar in plaats daarvan host.docker.internal.
Hollama en OrionChat: de browser doet het werk
Hollama serveert een browserapplicatie vanuit één kleine container. Chats worden opgeslagen in de opslag van uw browser, niet op de server.
docker run -d --restart unless-stopped -p 127.0.0.1:4173:4173 --name hollama ghcr.io/fmaclen/hollama:latestDe versie van dit commando in de self-hosting handleiding gebruikt --rm, waardoor de container wordt verwijderd zodra deze stopt. Hierdoor is de interface na een herstart niet meer beschikbaar.
OrionChat gaat nog een stap verder en heeft helemaal geen servercomponent. Kloon de repository en serveer de map met de webserver die u al gebruikt, of open index.html vanaf de schijf. API-sleutels worden opgeslagen in de localStorage van de browser, de chatgeschiedenis blijft in de browser en de app verwijdert de oudste chats zodra het aantal de 512 overschrijdt. Het Ollama-adres van OrionChat is vastgelegd in de broncode (js/script.js) op http://localhost:11434, en de instellingen bevatten geen veld om dit te wijzigen.
Geen van beide projecten heeft een inlogfunctie. Op een laptop is dat prima. Op een VPS betekent dit dat de pagina nooit op 0.0.0.0 gepubliceerd mag worden, en het betekent iets dat makkelijker over het hoofd wordt gezien: de browser roept het model aan, niet de server.
Dat ene feit bepaalt waar deze twee bruikbaar zijn. Uw browser moet Ollama rechtstreeks kunnen bereiken. Voor OrionChat betekent dit altijd localhost:11434 op de machine waarop de browser draait, dus een extern model vereist een tunnel of een lokale TCP-proxy die daar luistert. Windows netsh interface portproxy kan bijvoorbeeld die lokale poort doorsturen naar een bereikbare externe Ollama zonder OrionChat aan te passen. Hollama accepteert elk adres dat u invoert als de basis-URL van een verbinding, en de self-hosting handleiding behandelt een Ollama-server op een ander apparaat: voeg de origin van Hollama toe aan OLLAMA_ORIGINS aan de kant van Ollama. Tenzij u Ollama bereikt via een tunnel of proxy, moet Ollama dus op meer dan alleen loopback luisteren, en de API van Ollama vraagt niet om een inlognaam of sleutel. Hieruit volgen twee browserregels. Een pagina die via HTTPS wordt geserveerd, kan geen plat HTTP-eindpunt op een openbaar IP-adres aanroepen, en de console geeft Mixed Content: The page at 'https://chat.example.com/' was loaded over HTTPS, but requested an insecure resource 'http://203.0.113.10:11434/api/tags'. This request has been blocked. weer. Loopback heeft een aparte vrijstelling: de Mixed Content-specificatie blokkeert alleen URL's die niet als potentieel betrouwbaar worden beschouwd, en de Secure Contexts-specificatie rekent localhost, 127.0.0.0/8 en ::1 tot de potentieel betrouwbare, waardoor dezelfde HTTPS-pagina http://localhost:11434 of http://127.0.0.1:11434 kan aanroepen. Die vrijstelling is waar de onderstaande SSH-tunnel op vertrouwt. Sinds versie 142 voegt Chrome een stap toe wanneer de pagina afkomstig is van een openbare site zoals https://chat.example.com: een verzoek daarvandaan naar een loopback- of lokaal netwerkadres wacht totdat de gebruiker in een toestemmingsprompt toegang tot het lokale netwerk verleent. Chrome stelt HTTP-verzoeken aan eindpunten in het lokale netwerk die toestemming vereisen ook vrij van mixed-content-controles wanneer de hostnaam een privaat IP-literaal is zoals 192.168.0.1, een .local-naam, of wanneer de fetch targetAddressSpace: "local" specificeert. Een pagina die u opent via http://localhost door de tunnel bevindt zich al op loopback, dus die prompt is daar niet op van toepassing. Een aanroep naar een andere origin wordt geweigerd met has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource totdat u die origin toestaat.
De gedocumenteerde manier van Ollama om een van beide instellingen te wijzigen is een systemd-override.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_ORIGINS=https://chat.example.com"sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo ss -lntp | grep 11434ss zou nu 0.0.0.0:11434 moeten weergeven waar het voorheen 127.0.0.1:11434 weergaf. Voer deze wijziging alleen door wanneer een firewall of een authenticerende proxy al beheert wie de poort kan bereiken, omdat een open 11434 een open modelserver is en massascanners een nieuwe openbare poort snel vinden. De onderstaande SSH-tunnel vermijdt de hele kwestie: de pagina draait dan op een localhost-origin, wat Ollama standaard toestaat, en de poort verlaat nooit de machine.
Kan elk van deze een extern Ollama- of vLLM-eindpunt gebruiken?
Open WebUI kan dit, waarbij de verbinding aan de serverzijde wordt gemaakt. OLLAMA_BASE_URL=http://model-host:11434 wijst naar Ollama. Voor vLLM stelt u OPENAI_API_BASE_URL=http://model-host:8000/v1 in, waarbij u het /v1 behoudt waaronder vLLM zijn API aanbiedt. Stel OPENAI_API_KEY alleen in als de server met een sleutel is gestart, aangezien de vLLM-handleiding van Open WebUI anders geen authenticatie gebruikt. Andere OpenAI-compatibele servers accepteren het basispad dat in hun eigen documentatie staat, wat niet altijd /v1 is. OPENAI_API_BASE_URLS accepteert meerdere backends, gescheiden door puntkomma's.
LibreChat kan dit via de baseURL van het hierboven getoonde aangepaste eindpunt. Dat verzoek verlaat ook de server, dus er is geen browserregel van toepassing. Dezelfde basis-URL en dezelfde tijdelijke sleutel werken ook buiten een chatvenster, wat alles is wat nodig is om een codeer-agent naar het model te laten wijzen dat u al host.
Hollama kan naar elk eindpunt wijzen dat u in de instellingen invoert. De Ollama-verbinding heeft een bewerkbare basis-URL die standaard op http://localhost:11434 staat, en daarnaast biedt Hollama een OpenAI-compatibele verbinding, standaard http://localhost:8080/v1, wat de route naar vLLM is. Het verzoek verlaat uw browser, dus alles in de bovenstaande sectie is daarop van toepassing. OrionChat heeft geen instelling voor een extern eindpunt. De eindpunten zijn hardcoded, waarbij Ollama vaststaat op http://localhost:11434/v1/chat/completions, en de README vermeldt dat verzoeken rechtstreeks naar de officiële API van elke provider gaan. Een externe Ollama is bereikbaar via een SSH-tunnel of een lokale TCP-proxy die ervoor zorgt dat deze op die lokale poort antwoordt, en er is geen instelling voor een vLLM-server.
Het scheiden van de interface van het model is het grootste voordeel van een extern eindpunt. Plaats de interface op een kleine machine en het model op de plek waar het geheugen beschikbaar is. Dit is ook het moment om te beslissen of Ollama of vLLM de verzoeken moet afhandelen, omdat de twee zich heel anders gedragen zodra meerdere mensen tegelijkertijd met het model praten. Als de modelserver nog niet bestaat, begin dan met het draaien van Ollama op een VPS, en lees op een machine zonder GPU hoe Ollama zich verhoudt tot llama.cpp voordat u een runner kiest.
Publiceer nooit een chat-UI zonder inlogscherm op 0.0.0.0
De hardening-pagina van Open WebUI stelt dat het project is "gebouwd voor private, vertrouwde netwerken, vergelijkbaar met andere zelfgehoste infrastructuur zoals databases, container-registries en CI-servers". Het adviseert om de applicatie achter een VPN of een reverse proxy met authenticatie te plaatsen. Een project zonder enige vorm van inlogbeveiliging vereist ten minste dezelfde voorzorgsmaatregelen.
Controleer wat er luistert voordat u de configuratie vertrouwt.
sudo ss -lntp | grep -E ':(3000|3080|4173|11434)'Een regel met 127.0.0.1:3000 is wat u wilt zien. Een regel met 0.0.0.0:3000 betekent dat de service op alle adressen luistert. Docker staat standaard toe dat elk extern bron-IP een gepubliceerde poort bereikt. Tenzij een regel in de DOCKER-USER-chain van Docker of de firewall van uw provider dit blokkeert, is uw chat-interface toegankelijk vanaf het openbare internet. Vanaf uw eigen machine geeft curl -sI http://YOUR.VPS.IP:3000 met het antwoord HTTP/1.1 200 OK direct uitsluitsel.
Het uitschakelen van de inlogfunctie van Open WebUI met WEBUI_AUTH=False is een instelling voor één gebruiker op een machine die voor niemand anders bereikbaar is. De documentatie vermeldt bovendien dat dit alleen werkt bij een installatie zonder geregistreerde gebruikers; u kunt dit dus niet toepassen op een installatie waar al accounts bestaan.
Patroon één: bind aan loopback en benader via SSH. Publiceer elke poort op 127.0.0.1 en forward vervolgens wat u nodig heeft: ssh -N -L 3000:127.0.0.1:3000 you@vps.example.com, en open http://localhost:3000 op uw laptop. Gebruik Docker Engine 28.0.0 of nieuwer voor dit patroon; oudere releases staan toe dat hosts op hetzelfde L2-segment poorten bereiken die aan localhost zijn gebonden. Voor OrionChat forward u de modelpoort in hetzelfde commando met -L 11434:127.0.0.1:11434 en laat u Ollama op loopback staan. Hollama kan Ollama direct bereiken, maar dezelfde forward houdt Ollama buiten het openbare internet, wat ook voor Hollama de veiligere route is. De sterkte van dit patroon hangt af van uw SSH-configuratie; combineer het daarom met SSH met uitsluitend keys en een beveiligde sshd.
Patroon twee: een reverse proxy die authenticatie afhandelt voordat de app het verzoek ontvangt. Houd de app op loopback, laat de proxy poort 443 beheren en plaats single sign-on ervoor. Traefik aangestuurd door Docker Compose labels met Authentik als identity provider voorziet elke app op de server van één inlogmethode en één certificaat. Wanneer Open WebUI achter TLS (transport layer security) staat, stelt u WEBUI_SESSION_COOKIE_SECURE=true en WEBUI_SESSION_COOKIE_SAME_SITE=strict in. Verkort ook de standaardwaarde van JWT_EXPIRES_IN (vier weken), omdat Open WebUI documenteert dat zonder Redis een uitlogactie het token niet ongeldig maakt: het blijft bruikbaar totdat het vanzelf verloopt.
Patroon twee is niet geschikt voor projecten die uitsluitend in de browser draaien. Een proxy voor de pagina beschermt het model-endpoint niet. Een fetch vanuit die pagina naar een andere hostnaam bevat bovendien uw sessie-cookie niet, waardoor de authenticerende proxy voor Ollama antwoordt met een redirect naar een inlogformulier en de chat faalt. Route het model-endpoint onder dezelfde hostnaam als de pagina, of gebruik patroon één.
Welke optie moet u kiezen
Als iemand anders dan uzelf de tool gaat gebruiken, draai dan Open WebUI. Het beschikt over echte accounts, nieuwe gebruikers komen in een wachtrij voor goedkeuring terecht en de beheerders publiceren richtlijnen voor hardening die u kunt volgen. Als u LDAP of een beheerpaneel nodig heeft, draai dan LibreChat, stel ADMIN_PANEL_SESSION_SECRET in als u het paneel wilt gebruiken, en bevestig met docker stats of de vijf services (zes met het paneel) en uw model daadwerkelijk in het geheugen passen voordat u hiervan afhankelijk wordt. Als het voor één persoon is op een kleine server waar het model al het grootste deel van het RAM-geheugen in beslag neemt, serveer dan Hollama of OrionChat via een SSH-tunnel en laat de browser de status bijhouden. Het verkeerde antwoord op een VPS is een van deze opties publiceren op 0.0.0.0 zonder inlogscherm ervoor.
FAQ
Is het veilig om Open WebUI direct op een publiek IP-adres bloot te stellen?
De eigen hardening-pagina beschrijft de software als bedoeld voor private, vertrouwde netwerken, in dezelfde categorie als een database of een CI-server. Het beschikt wel over echte accounts, waarbij het eerste account een administrator wordt en latere accounts pending blijven totdat ze zijn goedgekeurd; het is dus aanzienlijk veiliger dan een UI zonder inlogprocedure. Plaats de applicatie desondanks achter een reverse proxy met TLS en, waar mogelijk, single sign-on. Publiceer de containerpoort als 127.0.0.1:3000:8080 en gebruik Docker Engine 28.0.0 of nieuwer voordat u vertrouwt op loopback-publicatie voor isolatie. Docker waarschuwt dat op oudere releases hosts op hetzelfde L2-segment poorten kunnen bereiken die naar localhost zijn gepubliceerd.
Welk Open WebUI-alternatief verbruikt het minste RAM op een VPS?
De browsergebaseerde opties, Hollama en OrionChat, omdat de applicatie op de client draait. De server verstuurt enkel statische bestanden en OrionChat heeft helemaal geen applicatiecontainer nodig. Open WebUI houdt een Python-proces, een database en, standaard, een lokaal embedding-model in het geheugen. Controleer de cijfers op uw eigen systeem met docker stats --no-stream, aangezien deze variëren afhankelijk van de functies die u inschakelt.
Kunnen deze chat-UI's een Ollama-server op een andere host gebruiken?
Open WebUI en LibreChat kunnen dit, waarbij hun server de verbinding tot stand brengt, waardoor de browserregel niet van toepassing is. Stel OLLAMA_BASE_URL in voor Open WebUI, of baseURL in een aangepast eindpunt voor LibreChat. Gebruik voor vLLM of een andere OpenAI-compatibele server OPENAI_API_BASE_URL met het basispad dat de server documenteert, wat voor vLLM /v1 is, en voeg alleen een API-sleutel toe als de server daarom vraagt. Hollama kan ook naar elke locatie verwijzen, maar het verzoek komt vanuit uw browser, dus het eindpunt moet ook vanuit uw browser bereikbaar zijn. Het Ollama-adres van OrionChat is hardcoded naar http://localhost:11434, dus een externe Ollama vereist een SSH-tunnel of een lokale TCP-proxy die die poort doorstuurt naar de bereikbare externe server.
Waarom kan mijn browser-chat-UI Ollama niet bereiken?
Twee oorzaken verklaren bijna elk geval. Ollama bindt standaard aan 127.0.0.1:11434, waardoor een browser op een andere machine het niet direct kan bereiken totdat OLLAMA_HOST wordt gewijzigd of een tunnel of proxy toegang biedt. Daarnaast accepteert Ollama standaard cross-origin-verzoeken van localhost, 127.0.0.1 en 0.0.0.0, waardoor een pagina die vanaf uw eigen domein wordt geserveerd, wordt geweigerd met No 'Access-Control-Allow-Origin' header is present on the requested resource totdat die oorsprong is vermeld in OLLAMA_ORIGINS. Als de pagina HTTPS is en het eindpunt platte HTTP op een publiek IP-adres, blokkeert de browser de aanroep als mixed content voordat Ollama deze ooit ziet. Loopback-adressen (localhost, elk adres in 127.0.0.0/8 zoals 127.0.0.2, of [::1]) zijn hiervan vrijgesteld. Chrome stelt ook HTTP-verzoeken binnen het lokale netwerk vrij die gebruikmaken van private IP-literals zoals 192.168.0.1, .local hostnames, of targetAddressSpace: "local" nadat toestemming voor het lokale netwerk is verleend; de CORS-vereisten van Ollama blijven echter van kracht. Stel beide variabelen in via een systemctl edit ollama.service-override, of stuur de poort door via SSH en het probleem is opgelost.