Ollama + Open WebUI: Ett sätt att köra LLM lokalt

Beräknad lästid: 5 minutes

Introduktion

Den här guiden visar hur du enkelt kan installera och köra stora språkmodeller (LLM) lokalt med Ollama och Open WebUI på Windows, Linux eller macOS – utan att behöva använda Docker. Ollama erbjuder lokal modellinläsning, och Open WebUI är ett användargränssnitt som förenklar interaktionen med dessa modeller. Upplevelsen är liknande som med gränssnitt som ChatGPT, Google Gemini eller Claude AI.

Varför köra Open WebUI utan Docker?

Genom att köra Open WebUI utan Docker kan du använda datorns resurser mer effektivt. Utan begränsningarna hos containeriserade miljöer kan all tillgänglig systemminne, CPU-kraft och lagring till fullo användas för att köra applikationen. Detta är särskilt viktigt när du arbetar med resurskrävande modeller, där varje bit av prestanda spelar roll.

Om du till exempel använder Open WebUI för att interagera med stora språkmodeller kan inhemsk körning resultera i snabbare bearbetningstider och smidigare prestanda, eftersom Docker inte behöver hantera containern. Genom att köra nativt får du också:

Enklare installation: Du undviker komplexiteten med att installera och hantera Docker-containrar, vilket kan vara särskilt fördelaktigt för användare som föredrar en enklare, direkt installation.
Förbättrad prestanda: Utan Dockers virtualisering finns en mer direkt koppling till systemresurserna, vilket kan leda till bättre prestanda för applikationen.
Direkt tillgång till systemresurser: Du har direkt kontroll över filvägar, inställningar och systemkonfigurationer, vilket gör felsökning och anpassning enklare.

Förutsättningar

Innan du börjar, se till att du har följande installerat på ditt system:

Python: Krävs för att köra Open WebUI.

Se till att du använder Python 3.11.X. Version 3.11.6 fungerar bra till exempel. Den senaste versionen av Python, 3.12.7, är inte kompatibel med den nuvarande versionen av Open WebUI.

Du kan ladda ner Python här. Se till att välja rätt version för ditt operativsystem. Python är ett mångsidigt programmeringsspråk som används flitigt inom AI och maskininlärning, inklusive utvecklingen och driften av stora språkmodeller (LLM). Om du vill utveckla dina kunskaper inom detta område, kolla in våra python-flashcards för ett snabbt och effektivt sätt att lära dig.

Installera Ollama

Gå till Ollama-nedladdningssidan.
Välj din plattform (Windows, Linux eller macOS) och ladda ner rätt version.
Installera Ollama genom standardinstallationsprocessen för din plattform.

Installera och köra Open WebUI

För att installera Open WebUI kan du använda Pythons pakethanterare pip. Följ dessa steg:

Öppna din terminal och kör följande kommando för att installera Open WebUI:
```
pip install open-webui
```
Efter installationen, uppdatera pip till den senaste versionen genom att köra:
```
python.exe -m pip install --upgrade pip
```
När Open WebUI är installerad, starta servern med följande kommando:
```
open-webui serve
```
Efter att Open WebUI har startats framgångsrikt kan du komma åt den i din webbläsare på: http://localhost:8080.

Om du föredrar kan du också installera Open WebUI genom att klona projektet direkt från GitHub. För mer information, se avsnittet i slutet av denna guide.

Konfigurera Ollama och ladda ner språkmodeller

Som standard sätter Ollama följande sökvägar för att lagra språkmodeller (LLM) på ditt system:

macOS: ~/.ollama/models
Linux: /usr/share/ollama/.ollama/models
Windows: C:\Users\%username%\.ollama\models

Du kan ändra denna sökväg om det behövs. På Windows kan du till exempel använda följande kommando:

setx OLLAMA_MODELS "D:\ollama_models"

Ställa in miljövariabler på macOS

Om du kör Ollama som en macOS-applikation bör miljövariabler ställas in med launchctl. Använd följande kommando för att ställa in en variabel:

launchctl setenv OLLAMA_MODELS "/new/path/to/models"

Efter att variabeln har ställts in, starta om Ollama-applikationen för att ändringarna ska träda i kraft.

Ställa in miljövariabler på Linux

För Linux-användare som kör Ollama som en systemd-tjänst kan du ställa in miljövariabler med systemctl. Här är hur du gör:

Öppna tjänstkonfigurationen genom att köra:
```
sudo systemctl edit ollama.service
```
Lägg till följande rad under [Service]-sektionen:
```
Environment="OLLAMA_MODELS=/new/path/to/models"
```
Spara filen och ladda om systemd samt starta om tjänsten:
```
sudo systemctl daemon-reload
```
```
sudo systemctl restart ollama
```

Ladda ner och köra språkmodeller i Ollama

För att ladda ner och köra språkmodeller i Ollama, använd följande kommandon i terminalen. Dessa kommandon laddar automatiskt ner modellen om den inte redan är installerad:

För att ladda ner och köra LLaMA 3.1-modellen från Meta (Facebook):
```
ollama run llama3.1
```
För att ladda ner och köra Gemma 2-modellen från Google:
```
ollama run gemma2
```

Använda Open WebUI

När Open WebUI är igång kan du komma åt den via http://localhost:8080. Efter att ha navigerat till denna adress uppmanas du att logga in eller registrera dig. För att skapa ett nytt konto, välj alternativet Skapa konto. Detta konto skapas lokalt, vilket innebär att det endast är tillgängligt på den här datorn och ingen annan användare på ditt system har tillgång till dina data.

Om du tidigare har startat Open WebUI och modellerna som laddats ner via Ollama inte visas på listan, uppdatera sidan för att uppdatera tillgängliga modeller. All data som hanteras inom Open WebUI lagras lokalt på din enhet, vilket säkerställer integritet och kontroll över dina modeller och interaktioner.

Installera Open WebUI med Git

Om du vill installera Open WebUI genom att klona projektet från GitHub och hantera det manuellt, följ dessa steg:

Förutsättningar:

Git: Se till att du har Git installerat på ditt system. Du kan ladda ner det här.
Anaconda: Det rekommenderas att använda Anaconda för att hantera din Python-miljö. Du kan ladda ner och installera Anaconda från här.

Installationsinstruktioner:

För Linux/macOS:

Öppna en terminal och navigera till katalogen där du vill klona arkivet.

Klona Open WebUI-arkivet med Git:

git clone https://github.com/open-webui/open-webui.git

Byt till projektkatalogen:
```
cd open-webui/
```
Kopiera .env-filen:
```
cp -RPp .env.example .env
```
Bygg frontend med Node.js:
```
npm install
```
```
npm run build
```
Gå in i backend-katalogen:
```
cd ./backend
```

(Valfritt) Skapa och aktivera en Conda-miljö:

conda create --name open-webui-env python=3.11

conda activate open-webui-env

Installera Python-beroenden:
```
pip install -r requirements.txt -U
```
Starta applikationen:
```
bash start.sh
```

För Windows:

Öppna en terminal och navigera till katalogen där du vill klona arkivet.