Spaces - eine Demo, die im Netz steht

Das hier ist das Kapitel, wegen dem der Kurs existiert.

Ein Space ist ein Git-Repo, das nicht nur Dateien enthält, sondern läuft. Du schiebst eine app.py hinein, der Hub baut einen Container daraus, startet ihn und gibt ihm eine Adresse. Danach kann jeder Mensch mit einem Browser deine Anwendung benutzen. Keine Domain, kein Reverse Proxy, kein Zertifikat, kein Server. Auf Wunsch mit GPU. Ohne Rechnung.

Wenn dich an Hugging Face etwas überraschen soll, dann das.

Die vier Sorten

Wir nehmen Gradio, aus einem Grund, der erst am Ende dieses Kapitels sichtbar wird: Ein Gradio-Space ist nicht nur eine Oberfläche.

Schritt 1 - Das Repo anlegen

hf repo create meine-erste-demo --repo-type space --space-sdk gradio

Der Befehl legt ein leeres Space-Repo unter deinem Namensraum an und nennt dir die URL. Der Space steht ab sofort im Netz - noch mit einer Fehlerseite, weil er keine Anwendung enthält.

Jetzt holst du ihn dir lokal:

git clone https://huggingface.co/spaces/deinbenutzername/meine-erste-demo
cd meine-erste-demo

Schritt 2 - Die Anwendung

Zwei Dateien, mehr braucht es nicht.

requirements.txt:

gradio
transformers
torch

app.py:

import gradio as gr
from transformers import pipeline

pipe = pipeline(
    "text-classification",
    model="oliverguhr/german-sentiment-bert",
    model_kwargs={"use_safetensors": True},
)


def stimmung(text: str) -> dict:
    """Schätzt die Stimmung eines deutschen Satzes."""
    ergebnis = pipe(text)[0]
    return {ergebnis["label"]: float(ergebnis["score"])}


demo = gr.Interface(
    fn=stimmung,
    inputs=gr.Textbox(label="Satz", lines=3),
    outputs=gr.Label(label="Stimmung"),
    title="Stimmung auf Deutsch",
    description="Ein kleines Modell schätzt, ob ein Satz positiv, negativ oder neutral klingt.",
    examples=[
        ["Die Lieferung kam drei Wochen zu spät."],
        ["Vielen Dank, alles hat einwandfrei geklappt."],
    ],
)

if __name__ == "__main__":
    demo.launch()

Dreißig Zeilen, und die Hälfte davon ist Beschriftung. Genau das ist Gradios Angebot: Die Oberfläche entsteht aus der Signatur deiner Funktion, nicht aus einem Template.

Vorher lokal ausprobieren lohnt sich - der Space baut sonst mit deinem Fehler:

pip install -r requirements.txt
python app.py
# → läuft auf http://127.0.0.1:7860

Schritt 3 - Hochschieben und zusehen

git add app.py requirements.txt
git commit -m "Erste Fassung: Stimmungserkennung auf Deutsch"
git push

Öffne jetzt die Space-Seite im Browser. Oben rechts steht Building. Unter Logs siehst du zu, wie der Container entsteht: Pakete werden installiert, das Modell wird beim ersten Start geladen. Beim ersten Mal dauert das ein paar Minuten, danach deutlich weniger.

Dann steht dort Running, und deine Anwendung ist unter

https://huggingface.co/spaces/deinbenutzername/meine-erste-demo

erreichbar. Für jeden. Ohne Login. Schick die Adresse jemandem, der keinen HF-Account hat - das ist die Probe.

Schritt 4 - Die Hardware, und was „kostenlos“ heißt

In den Space-Einstellungen steht unter Hardware die Liste der Stufen. Zwei davon kosten nichts (Stand August 2026):

CPU Basic ist die Voreinstellung: 2 vCPU, 16 GB RAM, dauerhaft kostenlos. Darauf läuft deine Demo gerade. Für kleine Klassifikationsmodelle, Embeddings, Datenanwendungen und alles, was nicht generiert, reicht das erstaunlich weit.

ZeroGPU ist die interessante: eine echte GPU, die nicht dir gehört, sondern zugeteilt wird - für die Sekunden, in denen deine Funktion rechnet. Sie ist für Gradio-Spaces kostenlos, mit einem Kontingent, das für den kostenlosen Account kleiner ist als für den bezahlten.

Umgestellt wird sie in den Einstellungen; im Code markierst du die Funktion, die die GPU braucht:

import spaces

@spaces.GPU
def generiere(prompt: str) -> str:
    ...

Alles darüber - eigene T4, L4, A10G, A100 - wird stundenweise abgerechnet, ab etwa 0,40 $ pro Stunde und nach oben offen (Stand August 2026). Das ist die Grenze, an der aus einer Demo ein Betriebskostenposten wird.

Schritt 5 - Geheimnisse

Wenn dein Space einen API-Schlüssel braucht, gehört der nicht ins Repo. In den Space-Einstellungen gibt es Variables and secrets: Variablen sind sichtbar, Secrets nicht. Beide landen als Umgebungsvariablen im Container.

import os

token = os.environ["HF_TOKEN"]   # als Secret hinterlegt, nicht im Code

Ein Space-Repo ist ein öffentliches Git-Repo mit Verlauf. Ein einmal committetes Token bleibt im Verlauf, auch wenn du es im nächsten Commit entfernst - dann hilft nur noch, es zu widerrufen.

Schritt 6 - Der Teil, den fast niemand kennt

Deine Demo ist nicht nur eine Oberfläche. Gradio stellt zu jeder Anwendung automatisch eine HTTP-API bereit - ganz unten auf der Seite steht der Link „Use via API“, mit fertigen Aufrufbeispielen.

Und seit Gradio das mitbringt, kann derselbe Space auch als MCP-Server antworten. Eine Zeile:

if __name__ == "__main__":
    demo.launch(mcp_server=True)

Danach hat dein Space zusätzlich einen MCP-Endpunkt, üblicherweise unter

https://deinbenutzername-meine-erste-demo.hf.space/gradio_api/mcp/sse

Aus dem Docstring deiner Funktion wird die Werkzeugbeschreibung, aus den Gradio-Eingabetypen wird das Schema. Deshalb steht in app.py oben ein Docstring - er ist nicht Dokumentation für Menschen, er ist die Beschreibung, die ein Modell liest.

Damit kippt die Bedeutung des Kapitels: Ein Space ist nicht nur eine Demo für Menschen, sondern ein Werkzeug für deinen Agenten. Wie ein Agent mit vielen solchen Werkzeugen umgeht, ohne dass sein Kontext explodiert, erklärt der Baustein Tiny Agents - und der gleichnamige Kurs baut es nach.

Der Meilenstein

Drei Dinge, alle prüfbar:

1. Eine öffentliche URL, die jemand ohne HF-Account im Browser öffnen kann und die dort etwas Sinnvolles tut.
2. Der Space läuft auf einer Stufe, die nichts kostet - in den Einstellungen steht CPU Basic oder ZeroGPU.
3. Der Aufruf des MCP-Endpunkts liefert eine Antwort statt eines 404:

curl -N https://deinbenutzername-meine-erste-demo.hf.space/gradio_api/mcp/sse

Punkt 1 kannst du verschicken. Punkt 3 kannst du in einen Agenten stecken.