Hösten 2026 släpps nya öppna språkmodeller nästan varje vecka, från Qwen3.8-Flash-Next till GLM-5.3-Flash. Problemet för de flesta svenska utvecklare är inte att hitta en modell, utan att visa upp den för kollegor, kunder eller en jury utan att bygga egen serverinfrastruktur. Hugging Face Spaces löser exakt det problemet: du laddar upp kod, väljer hårdvara och får en publik eller privat webbadress på minuter. I den här guiden bygger vi en fungerande AI-demo från grunden, med fokus på de säkerhetsmisstag som faktiskt drabbar riktiga projekt, som exponerade API-nycklar och Spaces som glöms kvar öppna för hela internet.
Du får tolv konkreta steg, ett komplett körbart projekt i Python, tre datatabeller med aktuell prissättning och färsk säkerhetsforskning om vad som faktiskt går fel när team publicerar AI-demos i skarpt läge. Guiden riktar sig till dig som redan följer utvecklingen inom öppna AI-modeller men ännu inte satt en modell i produktion, oavsett om målet är ett internt proof of concept eller en publik portföljdemo inför en anställningsintervju.
Vad är Hugging Face Spaces och varför är det aktuellt just nu
Hugging Face beskriver själva tjänsten rakt av: “Spaces is a simple way to host ML demo apps on the Hub”, enligt Hugging Faces officiella dokumentation. I praktiken är en Space en liten server som körs i en Docker-baserad sandbox, kopplad till ett git-repo som du kontrollerar precis som vilken kodbas som helst. Du väljer ett SDK, oftast Gradio eller Streamlit, skriver en app-fil, och Hugging Face bygger och driftsätter resten automatiskt.
Sedan lanseringen i oktober 2021 har communityn byggt och delat över 12 000 öppna maskininlärningsdemos via Spaces, enligt Hugging Faces egen blogg. Det gör tjänsten till en av de mest använda vägarna för att gå från en modellfil på disk till något en kollega kan klicka på i webbläsaren, utan att någon behöver installera Python lokalt. Just den friktionsfriheten är också anledningen till att Spaces blivit ett vanligt förstahandsval när nordiska team snabbt vill utvärdera en ny öppen modell innan de investerar i egen GPU-drift.
Två saker gör ämnet extra aktuellt hösten 2026. För det första har flödet av öppna modeller under 4 miljarder parametrar, som passar gratis CPU-hårdvara, fortsatt växa kraftigt under 2026. För det andra visar färsk forskning presenterad på ICSE 2026 att tusentals Spaces läcker API-nycklar rakt ut i loggar och källkod, ett problem den här guiden bygger in skydd mot från steg ett.
Till skillnad från att bara ladda ner en modell och köra den i ett Jupyter-notebook ger en Space dig något faktiskt delbart: en webbadress, ett gränssnitt byggt för slutanvändare, och en byggprocess som körs likadant varje gång oavsett vem som testar den. Det är skillnaden mellan “det fungerar på min dator” och “det fungerar för vem som helst med en webbläsare”, en skillnad som ofta avgör om ett internt AI-experiment någonsin blir taget vidare till en riktig utvärdering.
Förutsättningar: verktyg och versioner du behöver
Innan du börjar, se till att du har följande på plats. Ingen av delarna kräver betalkort, hela grundflödet går att köra på gratisnivån.
- Ett gratis konto på huggingface.co
- Python 3.10 eller nyare installerat lokalt (3.11 eller 3.12 rekommenderas)
- Git samt git-lfs för filer över 10 MB
- Paketet
gradio, version 6.27.0, som är den senaste stabila utgåvan enligt PyPI, släppt den 11 september 2026 - Paketen
transformersochhuggingface_hubi sina senaste versioner (kör alltidpip install --upgradevid start eftersom båda uppdateras ofta) - Ett terminalfönster med cirka 60 minuter avsatt tid
Du behöver inget grafikkort för grundprojektet i den här guiden. Vi kör en lättviktig modell på CPU Basic-nivån, som är gratis, och visar sedan hur du skalar upp om du vill köra en större modell.
Steg 1: Skapa konto och åtkomsttoken
Registrera ett konto på huggingface.co om du inte redan har ett. Gå därefter till kontoinställningarna och sektionen för åtkomsttokens (Access Tokens). Skapa en ny token med skrivbehörighet (write), eftersom du behöver den för att skapa och uppdatera din Space från terminalen senare i guiden.
Spara token i en lösenordshanterare, inte i en textfil på skrivbordet. Det här är den vanligaste källan till läckor bland nybörjare: tokens som ligger kvar i en .txt-fil, ett Slack-meddelande eller en delad anteckning. Behandla den som du skulle behandla ett lösenord till en produktionsdatabas. Skapa gärna en separat token bara för det här projektet, snarare än att återanvända en gammal token från ett annat sammanhang, så att du kan återkalla exakt rätt behörighet den dagen projektet avslutas utan att påverka något annat du byggt.
Steg 2: Installera Python, Git och Hugging Face CLI
Skapa en virtuell miljö och installera grundverktygen. Att isolera projektet i en egen miljö minskar risken för att gamla paketversioner från andra projekt smyger sig in i din requirements-fil senare.
python3 -m venv hf-space-env
source hf-space-env/bin/activate
pip install --upgrade pip
pip install gradio==6.27.0 transformers huggingface_hub torch
huggingface-cli loginKommandot huggingface-cli login ber om din token från steg 1 och sparar den lokalt i en skyddad konfigurationsfil. Verifiera att inloggningen fungerar genom att köra huggingface-cli whoami, som ska svara med ditt användarnamn.
Steg 3: Välj en öppen modell som passar din hårdvara
Det vanligaste nybörjarfelet är att välja en flaggskeppsmodell på över 100 miljarder parametrar och sedan bli förvånad när den gratis CPU-nivån vägrar starta. För en demo på CPU Basic behöver du en instruktionstränad modell under 4 miljarder parametrar. Tre etablerade, ofta använda alternativ 2026 listas nedan.
| Modell | Parametrar | Licens | Kräver godkänd åtkomst |
|---|---|---|---|
| Qwen1.5-1.8B-Chat (Alibaba) | Cirka 1,8 miljarder | Qwen-licens, anpassad öppen licens | Nej |
| Phi-3-mini-4k-instruct (Microsoft) | 3,8 miljarder | Microsofts öppna modellicens | Nej |
| Gemma-2-2b-it (Google) | 2 miljarder | Googles Gemma-licens | Ja, licensen måste godkännas på modellsidan |
I den här guiden använder vi Qwen1.5-1.8B-Chat eftersom den är liten, ungated och snabb att ladda ner. Vill du senare byta till Gemma eller Phi-3 räcker det att ändra en enda rad kod, resten av appen fungerar oförändrat. Tänk på att Gemma-modellerna kräver att du loggar in med ditt Hugging Face-konto och aktivt godkänner Googles licensvillkor på modellsidan innan nedladdningen ens startar, ett steg som lätt glöms bort och som annars visar sig som ett åtkomstfel mitt i byggprocessen.
Steg 4: Skapa din första Space
Logga in på huggingface.co, klicka på “New Space” och fyll i namn, till exempel oppen-ai-demo. Välj SDK “Gradio” och hårdvaran “CPU Basic”, som är kostnadsfri. Lämna synligheten på “Public” för nu, vi går igenom privat kontra publikt i steg elva.
När Spacen är skapad får du ett git-repo att klona lokalt, exakt som vilket GitHub-repo som helst. Enligt Hugging Faces dokumentation kan du dessutom bygga en demo direkt från de flesta modellsidor via knappen “Deploy till Spaces”, men i den här guiden bygger vi appen manuellt så att du förstår varje beslutspunkt.
git clone https://huggingface.co/spaces/DITT-ANVANDARNAMN/oppen-ai-demo
cd oppen-ai-demoSteg 5: Bygg gränssnittet med Gradio
Skapa en fil som heter app.py i mappen. Börja med ett minimalt gränssnitt så att du kan verifiera att driftsättningen fungerar innan du kopplar in själva modellen. Det steget sparar dig timmar av felsökning senare, eftersom du separerar infrastrukturproblem från modellproblem.
import gradio as gr
def echo(message, history):
return f"Du skrev: {message}"
demo = gr.ChatInterface(fn=echo, title="Testgranssnitt")
if __name__ == "__main__":
demo.launch()Testa lokalt med python app.py och öppna länken som skrivs ut i terminalen, oftast http://127.0.0.1:7860. Fungerar echo-svaret som väntat är grunden klar och du kan gå vidare till att koppla in den riktiga modellen.
Steg 6: Koppla modellen till appen
Byt ut testfunktionen mot ett riktigt anrop till Qwen1.5-1.8B-Chat via biblioteket transformers. Modellen laddas ner automatiskt första gången appen startar, vilket tar en stund på CPU Basic-hårdvara, men sparas sedan i cacheminnet för snabbare omstarter.
import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
MODEL_ID = "Qwen/Qwen1.5-1.8B-Chat"
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(MODEL_ID)
chat_pipeline = pipeline(
"text-generation",
model=model,
tokenizer=tokenizer,
device=-1,
)
def generate_reply(message, history):
prompt = tokenizer.apply_chat_template(
[{"role": "user", "content": message}],
tokenize=False,
add_generation_prompt=True,
)
output = chat_pipeline(
prompt,
max_new_tokens=200,
do_sample=True,
temperature=0.7,
)
reply = output[0]["generated_text"][len(prompt):].strip()
return reply
demo = gr.ChatInterface(
fn=generate_reply,
title="Oppen AI-demo pa Hugging Face Spaces",
description="En lattviktig chatbot byggd med Qwen1.5-1.8B-Chat, kord pa CPU Basic.",
)
if __name__ == "__main__":
demo.launch()Parametern device=-1 tvingar pipelinen att köra på CPU, vilket matchar hårdvaran vi valde i steg fyra. Testa lokalt igen innan du laddar upp, ett fel du hittar på din egen dator tar sekunder att fixa, samma fel upptäckt efter driftsättning kan ta tio minuter per försök på grund av byggkön.
Exempel på utdata: så ser en fungerande session ut
Innan du går vidare till driftsättning är det värt att veta exakt vad du letar efter när allt fungerar som det ska. Kör du python app.py lokalt ska terminalen skriva ut något i den här stilen, och webbläsaren ska öppna ett chattfönster där du kan skriva direkt.
$ python app.py
Loading checkpoint shards: 100%|##########| 2/2 [00:03<00:00, 1.62s/it]
Running on local URL: http://127.0.0.1:7860
Anvandare: Vad ar skillnaden mellan CPU Basic och ZeroGPU?
Assistent: CPU Basic ar en gratis, delad processor utan grafikkort,
medan ZeroGPU ger tillfallig tillgang till en kraftfull
GPU vid varje enskild forfragan, sedan slappt du resursen
igen. CPU Basic passar smA modeller under cirka 4
miljarder parametrar, ZeroGPU passar tyngre modeller
med sporadisk trafik.Notera raden Running on local URL, det är din bekräftelse på att Gradio startat korrekt. Efter driftsättning på Hugging Face byts adressen automatiskt ut mot din publika eller privata Space-URL, men själva svarsbeteendet i chattfönstret ska vara identiskt med det du testade lokalt. Skiljer sig svaren markant mellan lokal körning och den driftsatta versionen är första felsökningssteget nästan alltid en avvikande paketversion mellan din lokala miljö och requirements.txt.
Steg 7: Pinna beroenden i requirements.txt
Skapa en fil som heter requirements.txt i samma mapp. Hugging Face läser filen automatiskt och installerar paketen i byggmiljön innan appen startar. Pinna versioner med undre och övre gräns, inte bara ett nummer, så att en framtida stor uppdatering av transformers inte spränger din Space utan förvarning.
gradio==6.27.0
transformers>=4.44,<5
torch>=2.3,<3
accelerate>=0.33
huggingface_hub>=0.24Kör alltid pip freeze lokalt strax innan du laddar upp och jämför mot vad som faktiskt fungerade i din testmiljö. Skillnaden mellan “det som råkar finnas installerat” och “det som är explicit pinnat” är precis vad som orsakar de flesta byggfel i produktion.
Steg 8: Ladda upp koden och driftsätt din Space
Med app.py och requirements.txt på plats kan du driftsätta på två sätt. Det enklaste är git, som fungerar identiskt med vilket annat repo som helst.
git add app.py requirements.txt
git commit -m "Lagg till Gradio-chatbot med Qwen1.5-1.8B-Chat"
git pushAlternativet är att använda huggingface_hub-biblioteket direkt från ett Python-skript, praktiskt om du redan har byggprocessen automatiserad i ett CI/CD-flöde.
from huggingface_hub import HfApi
api = HfApi()
api.upload_folder(
folder_path="./oppen-ai-demo",
repo_id="DITT-ANVANDARNAMN/oppen-ai-demo",
repo_type="space",
)Efter push börjar Hugging Face bygga containern automatiskt. Du ser byggloggen live under fliken “Logs” i din Space, vilket är den plats du alltid ska kolla först om något går fel.
Steg 9: Välj hårdvara och förstå prissättningen
CPU Basic räcker gott för en modell under 4 miljarder parametrar, men om du vill köra något större behöver du en betald hårdvarunivå. Tabellen nedan visar aktuell prissättning per timme enligt Hugging Faces officiella prislista för Spaces-hårdvara.
| Hårdvara | vCPU | RAM | VRAM | Pris per timme |
|---|---|---|---|---|
| CPU Basic | 2 | 16 GB | – | Gratis |
| CPU Upgrade | 8 | 32 GB | – | 0,03 USD |
| Nvidia T4 – small | 4 | 15 GB | 16 GB | 0,40 USD |
| Nvidia T4 – medium | 8 | 30 GB | 16 GB | 0,60 USD |
| 1x Nvidia L4 | 8 | 30 GB | 24 GB | 0,80 USD |
| Nvidia A10G – small | 4 | 15 GB | 24 GB | 1,00 USD |
| 1x Nvidia L40S | 8 | 62 GB | 48 GB | 1,80 USD |
| Nvidia A100 – large | 12 | 142 GB | 80 GB | 2,50 USD |
| ZeroGPU | Dynamisk | Dynamisk | Upp till 96 GB | Gratis för Pro-konton |
ZeroGPU är värt att notera separat: det ger tillfällig åtkomst till kraftfulla GPU:er utan att du behöver hyra hårdvara per timme, men det kräver ett betalt Pro-konto och fungerar bäst för korta, sporadiska anrop snarare än en app som ständigt hanterar trafik. Väljer du fel hårdvara för en stor modell blir den vanligaste konsekvensen att containern kraschar med slut-på-minne-fel redan under uppstart, långt innan någon användare ens hunnit skriva ett meddelande.
En enkel tumregel för att uppskatta minnesbehov: räkna med ungefär två gigabyte VRAM eller RAM per miljard parametrar om modellen körs i 16-bitars precision, och ungefär hälften av det om du kvantiserar till 8-bitars. Qwen1.5-1.8B-Chat i det här projektet klarar sig med god marginal på CPU Basics 16 GB RAM, medan en modell på 13 miljarder parametrar redan börjar bli trång på samma hårdvara och mår bättre av åtminstone en T4-medium.
Steg 10: Skydda API-nycklar med Spaces Secrets
Så snart din app behöver anropa en extern tjänst, till exempel en innehållsmodereringstjänst eller en betald AI-modell via API, får du aldrig skriva nyckeln direkt i app.py. Gå till fliken “Settings” i din Space och lägg till en hemlighet under “Repository secrets”. Namnge den tydligt, till exempel MODERATION_API_KEY, och läs sedan ut den i koden via miljövariabler.
import os
import requests
MODERATION_KEY = os.environ.get("MODERATION_API_KEY")
def is_safe(text):
response = requests.post(
"https://api.din-tjanst.example/v1/check",
headers={"Authorization": f"Bearer {MODERATION_KEY}"},
json={"text": text},
timeout=5,
)
return response.json().get("safe", True)Det här är inte en teoretisk risk. En studie presenterad på ICSE 2026, “A Large-Scale Empirical Study of Secret Key Leakage in Hugging Face Spaces”, identifierade 9 149 Spaces med läckande hemligheter och 11 557 unika nycklar, varav 76 procent kom från stora AI-leverantörer som OpenAI och Groq. Den vanligaste orsaken var inte trasiga Secrets-inställningar, utan utvecklare som av misstag skrev ut nyckeln i loggar, felmeddelanden eller direkt i klientkoden. Skriv aldrig print(MODERATION_KEY) under felsökning, och se till att felmeddelanden i din app aldrig returnerar råa undantag som kan innehålla miljövariabler.
Steg 11 och 12: Privat eller publik, testa och publicera
Som standard är alla gratis Spaces publika, synliga för vem som helst med länken och sökbara via Hugging Faces katalog. För en snabb portföljdemo är det sällan ett problem, men för en prototyp med kundens data, interna dokument eller en obekräftad affärsidé bör du göra Spacen privat. Det kräver minst ett Pro-konto.
| Plan | Pris | Privata Spaces | ZeroGPU | Övrigt |
|---|---|---|---|---|
| Free | 0 USD | Nej | Nej | Publika Spaces, CPU Basic gratis |
| Pro | 20 USD per månad | Ja | Ja | Snabbare kö och fler resurser |
| Enterprise | 25 USD per användare och månad, plus GPU-kostnad | Ja | Ja | SSO och teamhantering |
Innan du delar länken med någon annan, testa hela flödet från en annan enhet eller ett inkognitofönster. Skicka minst tio olika typer av meddelanden, inklusive tomma strängar, extremt långa texter och specialtecken, för att se hur appen hanterar kanterna. Kontrollera sedan byggloggen en sista gång och verifiera att inga hemligheter syns i klartext någonstans i utskrifterna. När allt ser rent ut byter du synlighet, om det behövs, och delar länken.
Datasuveränitet och GDPR: vad du bör tänka på innan du publicerar
För en svensk organisation räcker det sällan att fråga om en Space fungerar tekniskt. Frågan som kommer från jurist- eller säkerhetsavdelningen är oftast var datan faktiskt bearbetas. Skriv aldrig in riktiga personuppgifter, kundnummer eller interna dokument i en testchatt på en publik Space, även om syftet bara är att demonstrera en funktion för en kollega. Allt du skriver i gränssnittet skickas till containern som kör din kod, och om du dessutom vidarebefordrar texten till en extern API-tjänst passerar den ytterligare ett företag utanför din egen kontroll.
Vill du bygga något som ska hantera riktig kunddata, håll dig till tre principer. Använd syntetiska eller anonymiserade exempel under själva utvecklings- och demofasen. Gör Spacen privat, vilket som beskrivits ovan kräver ett Pro-konto, så snart innehållet rör sig bortom en ren teknikdemo. Och läs igenom villkoren för Enterprise-planen om projektet ska gå i produktion med skarp data, eftersom den nivån innehåller de avtalsmässiga garantier kring datahantering som en offentlig gratisnivå aldrig kan ge. Samma resonemang gäller oavsett om modellen körs på Hugging Face, i din egen molnmiljö, eller helt lokalt, vilket vi går igenom mer i grunden i vår guide om att köra öppna modeller lokalt utan att data lämnar din egen dator.
Det gäller även vilken modell du väljer att bygga demot kring. Modeller med öppna vikter, som de tre i tabellen ovan, går att granska, köra offline och i värsta fall byta ut utan att du är beroende av en enskild molnleverantörs API. En sluten modell bakom ett betal-API kan ge bättre svar rent kvalitetsmässigt, men innebär samtidigt att varje testmeddelande din organisation skriver in passerar ytterligare ett företags servrar, något som är värt att väga in redan när du bestämmer vilken modell som ska driva din första Space.
Fem vanliga misstag som saboterar din Space
- Hårdkodade nycklar i app.py. Även om repot är privat idag kan synligheten ändras senare, eller så klonar någon repot innan du hinner ångra dig. Använd alltid Secrets, aldrig klartext i koden. Kom ihåg att git behåller hela historiken, så att i efterhand ta bort en rad med en nyckel räddar dig inte, nyckeln finns kvar i ett tidigare commit och måste roteras hos leverantören.
- Opinnade beroenden. En rad som bara säger
transformersutan versionsnummer betyder att din Space kan sluta fungera helt utan att du ändrat en enda kodrad, bara för att ett nytt paket släpptes. Det här är särskilt vanligt när ett projekt legat orört i några månader och du plötsligt bygger om det inför en demo, exakt när du minst har tid att felsöka. - Fel hårdvara för modellstorleken. En modell på 7 miljarder parametrar i full precision ryms sällan på CPU Basic. Kontrollera modellkortets rekommenderade minneskrav innan du väljer hårdvara, och räkna med att en modell i 16-bitars precision ungefär behöver dubbelt så mycket minne som antalet parametrar i miljarder, uttryckt i gigabyte.
- Glömd git-lfs för stora filer. Modellvikter över 10 MB måste hanteras via git-lfs, annars avvisar Hugging Face pushen eller så laddas filen upp trasig. Kör alltid
git lfs installen gång per maskin innan du börjar arbeta med ett repo som innehåller modellfiler. - Ingen hantering av vilotillstånd. Gratis CPU Basic-Spaces pausas automatiskt efter 48 timmars inaktivitet. Bygg in ett tydligt laddningsmeddelande så att den första besökaren efter en paus inte tror att appen är trasig under uppstarten, särskilt om du delar länken i ett sammanhang där du inte själv kan testa den precis innan, som ett jobbmejl som skickas sent på kvällen.
- Blandad indentering och radbrytningar i Python-filer. Kopierar du kod mellan operativsystem kan osynliga teckenskillnader i radslut orsaka syntaxfel som är svåra att se med blotta ögat i en vanlig editor, men som stoppar hela bygget.
Felsökning: åtta problem och lösningar
- Build error med exitkod 1: Öppna byggloggen och leta efter den sista raden innan kraschen, oftast en paketkonflikt mellan två bibliotek som kräver olika versioner av samma beroende. Testa exakt samma requirements.txt lokalt med en helt ny virtuell miljö innan du felsöker vidare i molnet, det är snabbare och billigare än att gissa via byggloggen.
- Spacen fastnar på “Building” i flera minuter: Normalt vid första bygget eftersom stora paket som torch laddas ner och modellen hämtas för första gången. Vänta minst fem minuter innan du antar att något är fel, och jämför gärna med byggtiden för en helt tom testapp för att få en känsla för vad som är normalt i just ditt projekt.
- CUDA out of memory: Modellen är för stor för vald GPU. Byt till en mindre modell, kvantisera vikterna till 8-bitars eller 4-bitars precision, eller uppgradera till en hårdvarunivå med mer VRAM enligt tabellen i steg nio.
- Vit eller tom sida i webbläsaren: Kontrollera att
demo.launch()faktiskt anropas och att inga JavaScript-fel blockerar renderingen i webbläsarens konsol. Testa även att ladda om sidan med en tom cache, gamla resurser som fastnat i webbläsarens cache är en vanlig men lätt förbisedd orsak. - KeyError när koden läser en hemlighet: Namnet i koden matchar inte namnet du satte under Settings. Kontrollera stavning och versaler, miljövariabelnamn är skiftlägeskänsliga, och glöm inte att spara sidan i Settings innan du bygger om Spacen.
- Långsam eller misslyckad första förfrågan efter paus: Detta är kallstart efter 48 timmars vila. Andra och senare förfrågningar blir snabba igen så snart containern är uppe, så låt aldrig en enda misslyckad första förfrågan lura dig att appen är trasig.
- Git push nekas på grund av stora filer: Kör
git lfs installochgit lfs track "*.bin"innan du committar modellfiler, annars stoppar Hugging Face pushen med ett felmeddelande om filstorlek. - “Bad credentials” vid inloggning eller push: Din token har antingen gått ut eller saknar skrivbehörighet. Skapa en ny token med rätt behörighet under kontoinställningarna och kör
huggingface-cli loginigen. - Appen svarar men ignorerar systeminstruktioner eller historik: Kontrollera att chattmallen från
apply_chat_templatefaktiskt inkluderar tidigare meddelanden när du bygger vidare på grundprojektet, annars minns modellen bara det senaste inlägget i varje enskild förfrågan.
Avancerade tips: ZeroGPU, CI/CD och skalning
När grundprojektet fungerar finns flera sätt att förbättra det. För sporadisk men tung trafik, testa ZeroGPU istället för en dedikerad GPU-hårdvara som faktureras per timme dygnet runt, det ger tillgång till kraftfulla acceleratorer bara när en förfrågan faktiskt kommer in. För team som redan har ett GitHub-repo, koppla en GitHub Action som synkar till Hugging Face-repot vid varje merge till huvudgrenen, så slipper du manuell push helt.
Om din Space behöver spara data mellan sessioner, till exempel användarfeedback eller cachade svar, tänk på att standarddisken är tillfällig och nollställs vid omstart. Persistent lagring finns som tillval på betalda hårdvarunivåer och bör användas istället för att lita på det lokala filsystemet för allt som måste överleva en omstart. Sist, sätt alltid en anpassad viloparameter med set_space_sleep_time() på betald hårdvara om du vill styra exakt när containern ska pausas, en möjlighet som inte finns på gratis CPU Basic där tiden är låst till 48 timmar.
Bevaka gärna kostnaden löpande om du kör betald hårdvara. Sätt ett kalenderpåminnelse för att kontrollera faktureringssidan varje vecka de första månaderna, tills du fått en känsla för hur mycket trafik din Space faktiskt genererar. En vanlig nybörjarfälla är att lämna en dyr GPU-nivå aktiv för en intern demo som bara används en gång i veckan, när CPU Basic eller ZeroGPU hade räckt lika bra till en bråkdel av kostnaden.
Säkerhet: lärdomen från läckta API-nycklar i Spaces
Forskningen från ICSE 2026 pekar på ett mönster som går igen i nästan alla säkerhetsincidenter kring API-nycklar, inte bara på Hugging Face: verktyget för att göra rätt fanns redan där, men utvecklaren tog en genväg under tidspress. Secrets-funktionen i Spaces fungerar precis som miljövariabler i vilken molntjänst som helst, nyckeln injiceras i containern vid körning och ska aldrig behöva synas i själva källkoden.
Tre konkreta vanor minskar risken kraftigt. Granska alltid diffen innan en commit, särskilt filer som config.py eller .env som lätt glöms bort i en git add .. Lägg till en .gitignore-fil som utesluter lokala miljöfiler redan innan du skriver första raden kod. Testa gärna även ett verktyg för hemlighetsskanning i ditt lokala arbetsflöde innan varje push, ett ämne vi går igenom mer i detalj i vår guide om hemlighetsskanning med Gitleaks. Kombinationen av Spaces Secrets och en lokal skanner täcker de två vanligaste läckvägarna: miljövariabler som körs fel, och nycklar som råkar hamna i en commit innan de ens når servern. Rotera dessutom nyckeln omedelbart om du någon gång misstänker att den synts i en logg eller ett skärmdelningsmöte, oavsett hur kort tid den varit exponerad, kostnaden för att skapa en ny nyckel är försumbar jämfört med kostnaden för ett missbrukat konto hos en betald AI-leverantör.
Vill du bredda projektet ytterligare är våra guider om att finjustera en egen modell med Hugging Face och att köra AI-modeller helt lokalt med LM Studio naturliga nästa steg om du vill gå bortom en publik demo. För den som vill jämföra vilka öppna modeller som faktiskt presterar bäst just nu innan du väljer vilken som ska driva din Space är vår genomgång av öppna AI-modeller och deras benchmarkresultat ett bra ställe att börja. Kör du redan flera modeller lokalt kan vår guide om att köra DeepSeek och Llama 4 lokalt vara ett komplement snarare än en ersättning för en publik Space.
Space eller lokal körning: när passar vilket val
En vanlig fråga efter det här projektet är om Spaces ens är rätt lösning, eller om det är enklare att bara köra allt lokalt. Svaret beror på vem som ska använda demot. Ska bara du själv testa en modell under utveckling, sparar lokal körning både tid och pengar, du slipper vänta på byggköer och behöver aldrig oroa dig för publik exponering. Verktyg som Ollama eller LM Studio, som vi gått igenom i tidigare guider, är ofta snabbare att komma igång med för rent personligt bruk.
Så snart någon annan än du själv behöver testa modellen förändras kalkylen. En kollega på ett annat kontor, en kund som ska godkänna ett koncept, eller en jury i en teknisk intervju kan inte förväntas installera Python och ladda ner flera gigabyte modellvikter bara för att se en demo. Där vinner Spaces varje gång, eftersom hela poängen är en länk som fungerar direkt i webbläsaren. En praktisk tumregel: använd lokal körning under själva utvecklingen och byt till en Space så fort demot ska visas för någon utanför ditt eget skrivbord.
Vanliga frågor
Är Hugging Face Spaces gratis att använda?
Ja, CPU Basic-hårdvaran är helt kostnadsfri och räcker för de flesta demos med modeller under 4 miljarder parametrar. Betalning krävs först om du vill ha GPU-hårdvara, privata Spaces eller ZeroGPU-åtkomst.
Vilken hårdvara ska jag välja för en enkel chatbot-demo?
Börja alltid med CPU Basic. Byt bara till en betald GPU-nivå om modellen faktiskt kräver det, vilket du ser genom att kontrollera minneskraven på modellens sida på Hugging Face innan du driftsätter.
Kan jag köra en svensk eller nordisk språkmodell på Spaces?
Ja, du laddar bara upp valfri modell-id från Hugging Face Hub istället för Qwen1.5-1.8B-Chat i koden, till exempel en svensktränad modell om en sådan finns publicerad öppet. Kontrollera bara att modellens parameterstorlek matchar den hårdvara du valt, och testa alltid svaren på svenska specifikt eftersom en del mindre modeller presterar klart sämre utanför engelska.
Hur skyddar jag API-nycklar i min Space på bästa sätt?
Använd alltid funktionen Repository secrets under Settings, läs ut värdet via os.environ i koden, och skriv aldrig ut nyckeln i loggar, felmeddelanden eller kod som skickas till klienten.
Varför somnar min gratis Space och hur väcker jag den?
Spaces på CPU Basic pausas automatiskt efter 48 timmars inaktivitet för att spara resurser. Nästa besökare som öppnar länken startar containern igen automatiskt, men får vänta en kort stund under uppstarten.
Måste jag betala för att göra min Space privat?
Ja, privata Spaces kräver minst ett Pro-konto för 20 USD per månad. På gratisnivån är alla Spaces publika och synliga för alla med länken.
Kan jag använda Docker istället för Gradio?
Ja, Hugging Face stödjer även ett rent Docker-SDK om du vill bygga en helt egen webbserver istället för att använda Gradios färdiga komponenter. Det ger mer kontroll men kräver mer eget arbete kring gränssnittet.
Vad händer om jag glömmer pinna versioner i requirements.txt?
Din Space kan fungera perfekt idag och sluta bygga om några veckor utan att du rört koden, eftersom ett nytt paket kan bryta bakåtkompatibiliteten. Pinna alltid versioner med tydliga övre gränser för att undvika det.
