> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fim.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Schnellstart

> Starten Sie FIM One in Minuten – oder probieren Sie die Cloud-Version sofort aus.

<Tip>
  **☁️ Option 0: Cloud (Keine Einrichtung erforderlich)**
  Möchten Sie nicht selbst hosten? Probieren Sie FIM One sofort unter [**cloud.fim.ai**](https://cloud.fim.ai/) aus – kein Docker, keine API-Schlüssel, keine Konfiguration. Melden Sie sich an und schon können Sie loslegen. *Früher Zugriff.*
</Tip>

## Option A: Docker (Empfohlen)

Keine lokale Python- oder Node.js-Installation erforderlich — alles wird im Container erstellt.

```bash theme={null}
git clone https://github.com/fim-ai/fim-one.git
cd fim-one

# Configure — only LLM_API_KEY is required
cp example.env .env
# Edit .env: set LLM_API_KEY (and optionally LLM_BASE_URL, LLM_MODEL)

# Build and run (first time, or after pulling new code)
docker compose up --build -d
```

Öffnen Sie [http://localhost:3000](http://localhost:3000) — beim ersten Start werden Sie durch die Erstellung eines Admin-Kontos geführt. Das war's.

Nach dem ersten Build benötigen nachfolgende Starts nur:

```bash theme={null}
docker compose up -d          # start (skip rebuild if image unchanged)
docker compose down           # stop
docker compose logs -f        # view logs
```

Daten werden in Docker Named Volumes (`fim-data`, `fim-uploads`) gespeichert und bleiben nach Container-Neustarts erhalten.

**Hinweis:** Der Docker-Modus unterstützt kein Hot Reload. Code-Änderungen erfordern ein Neuerstellen des Images (`docker compose up --build -d`). Für aktive Entwicklung mit Live Reload verwenden Sie **Option B** unten.

## Option B: Lokale Entwicklung

Voraussetzungen: Python 3.11+, [uv](https://docs.astral.sh/uv/), Node.js 18+, pnpm.

```bash theme={null}
git clone https://github.com/fim-ai/fim-one.git
cd fim-one

cp example.env .env
# Edit .env: set LLM_API_KEY

# Install
uv sync --all-extras
cd frontend && pnpm install && cd ..

# Launch (with hot reload)
./start.sh
```

| Befehl               | Was wird gestartet                                         | URL                                                               |
| -------------------- | ---------------------------------------------------------- | ----------------------------------------------------------------- |
| `./start.sh`         | Next.js + FastAPI                                          | [http://localhost:3000](http://localhost:3000) (UI) + :8000 (API) |
| `./start.sh dev`     | Dasselbe, mit Hot Reload (Python `--reload` + Next.js HMR) | Dasselbe                                                          |
| `./start.sh dev:api` | Nur API, Dev-Modus (`--reload`)                            | [http://localhost:8000/api](http://localhost:8000/api)            |
| `./start.sh dev:ui`  | Nur Next.js, Dev-Modus (HMR)                               | [http://localhost:3000](http://localhost:3000)                    |
| `./start.sh api`     | Nur FastAPI (headless, für Integration oder Tests)         | [http://localhost:8000/api](http://localhost:8000/api)            |

## Konfiguration

FIM One funktioniert mit **jedem OpenAI-kompatiblen LLM-Anbieter** — OpenAI, DeepSeek, Anthropic, Qwen, Ollama, vLLM und mehr.

| Anbieter           | `LLM_API_KEY` | `LLM_BASE_URL`                 | `LLM_MODEL`         |
| ------------------ | ------------- | ------------------------------ | ------------------- |
| **OpenAI**         | `sk-...`      | *(Standard)*                   | `gpt-4o`            |
| **DeepSeek**       | `sk-...`      | `https://api.deepseek.com/v1`  | `deepseek-chat`     |
| **Anthropic**      | `sk-ant-...`  | `https://api.anthropic.com/v1` | `claude-sonnet-4-6` |
| **Ollama** (lokal) | `ollama`      | `http://localhost:11434/v1`    | `qwen2.5:14b`       |

**[Jina AI](https://jina.ai/)** ermöglicht Websuche/Abruf, Einbettung und die vollständige RAG-Pipeline (kostenlose Stufe verfügbar).

Minimale `.env`:

```bash theme={null}
LLM_API_KEY=sk-your-key
# LLM_BASE_URL=https://api.openai.com/v1   # default — change for other providers
# LLM_MODEL=gpt-4o                         # default — change for other models

JINA_API_KEY=jina_...                       # unlocks web tools + RAG
```

Eine vollständige Liste aller Konfigurationsoptionen finden Sie in der Referenz [Umgebungsvariablen](/configuration/environment-variables).

## Produktionsbereitstellung

### Docker (Empfohlen)

`docker compose up -d` startet alles, was Sie benötigen — **keine manuelle Servicekonfiguration erforderlich**:

| Service     | Zweck                        | Konfiguriert von                       |
| ----------- | ---------------------------- | -------------------------------------- |
| **fim-one** | API + Frontend               | `.env` (Ihre LLM-Schlüssel, etc.)      |
| **Redis**   | Cross-Worker-Interrupt-Relay | Automatisch konfiguriert durch Compose |

```bash theme={null}
docker compose up --build -d   # first time / after code changes
docker compose up -d           # subsequent starts
docker compose logs -f         # view logs
docker compose down            # stop all services
```

#### Skalierung mit Workern

Standardmäßig wird die API mit einem einzelnen Worker-Prozess ausgeführt. Um mehr gleichzeitige Benutzer zu verarbeiten, erhöhen Sie die Worker über `.env`:

```bash theme={null}
WORKERS=4   # number of Uvicorn worker processes
```

Anforderungen für mehrere Worker:

* **PostgreSQL** — SQLite ist ein Single-Writer und unterstützt keine gleichzeitigen Schreibvorgänge. Setzen Sie `DATABASE_URL` auf eine PostgreSQL-Verbindungszeichenfolge.
* **Redis** — bereits in Docker Compose enthalten (automatisch konfiguriert). Verwaltet das Cross-Worker-Interrupt/Inject-Relay.

Mit `WORKERS=1` (Standard) sind weder Redis noch PostgreSQL erforderlich — SQLite funktioniert einwandfrei.

#### Nginx Reverse Proxy

Für HTTPS und benutzerdefinierte Domäne setzen Sie einen Nginx-Reverse-Proxy davor:

```
User → Nginx (443/HTTPS) → localhost:3000
```

Die API läuft intern auf Port 8000 — Next.js leitet `/api/*`-Anfragen automatisch weiter. Nur Port 3000 muss freigegeben werden.

#### Code Execution Sandbox

Wenn Sie die Code-Ausführungs-Sandbox (`CODE_EXEC_BACKEND=docker`) verwenden, mounten Sie den Docker-Socket:

```yaml theme={null}
# docker-compose.yml
volumes:
  - /var/run/docker.sock:/var/run/docker.sock
```

#### Cloudflare Tunnel

Verwenden Sie für ein Setup ohne offene Ports [Cloudflare Tunnel](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) anstelle von Nginx. Der gesamte Datenverkehr fließt über Cloudflares Edge — es ist nicht erforderlich, die Ports 80/443 freizugeben, SSL-Zertifikate zu verwalten oder Firewall-Regeln zu konfigurieren.

<Warning>
  **Benutzer in Festlandchina**: Cloudflare Free/Pro/Business-Pläne haben **keine PoPs (Points-of-Presence) in Festlandchina**. Der Datenverkehr aus Festlandchina wird zu Overseas-Edges weitergeleitet (typischerweise US West), was häufig zu 502-Fehlern und hoher Latenz führt. Verwenden Sie **nicht** Cloudflare Tunnel, wenn Ihre primären Benutzer in Festlandchina sind. Cloudflare Enterprise mit China Network (JD Cloud-Partnerschaft) ist erforderlich für zuverlässigen Zugriff auf Festlandchina.
</Warning>

```
User → Cloudflare Edge (SSL) → Tunnel → cloudflared → fim-one:3000
```

**Einrichtung:**

<Steps>
  <Step title="Tunnel erstellen">
    Gehen Sie zu [Cloudflare Zero Trust](https://one.dash.cloudflare.com/) → Networks → Tunnels → **Create a tunnel**.
    Wählen Sie **Cloudflared** als Connector-Typ.
  </Step>

  <Step title="Öffentlichen Hostnamen konfigurieren">
    Fügen Sie in der Tunnel-Konfiguration einen öffentlichen Hostnamen hinzu:

    | Feld     | Wert           |
    | -------- | -------------- |
    | **Type** | `HTTP`         |
    | **URL**  | `fim-one:3000` |

    Lassen Sie alle anderen Einstellungen (HTTP Host Header, Chunked Encoding, Timeouts, Access) auf ihren Standardwerten.

    <Note>Die URL verwendet den Docker-Servicenamen `fim-one`, nicht `localhost`, da `cloudflared` als separater Container im selben Docker-Netzwerk ausgeführt wird.</Note>
  </Step>

  <Step title="Tunnel-Token kopieren">
    Suchen Sie auf der Seite **Configure** des Tunnels den Installationsbefehl — er enthält einen Token, der mit `eyJ...` beginnt. Kopieren Sie ihn.
  </Step>

  <Step title="Token zu .env hinzufügen">
    ```bash theme={null}
    # Add to your .env file on the server
    CLOUDFLARE_TUNNEL_TOKEN=eyJhIjoiNj...
    ```
  </Step>

  <Step title="Mit dem Tunnel-Overlay bereitstellen">
    ```bash theme={null}
    docker compose -f docker-compose.yml -f docker-compose.tunnel.yml build
    docker compose -f docker-compose.yml -f docker-compose.tunnel.yml up -d
    ```

    Das `docker-compose.tunnel.yml`-Overlay fügt einen `cloudflared`-Sidecar-Container hinzu. Die Basis-`docker-compose.yml` bleibt unverändert — Community-Benutzer ohne Cloudflare können weiterhin `docker compose up -d` wie zuvor verwenden.
  </Step>

  <Step title="Alten DNS-Eintrag entfernen">
    Wenn Ihre Domain zuvor einen A-Eintrag hatte, der auf die IP-Adresse Ihres Servers verweist, **löschen Sie ihn** in Cloudflare DNS. Der Tunnel erstellt automatisch einen CNAME-Eintrag, der auf seinen Edge-Endpunkt verweist.
  </Step>

  <Step title="Server-Ports schließen">
    Entfernen Sie (oder kommentieren Sie aus) den Abschnitt `ports` aus `docker-compose.yml` auf Ihrem Server. Der Datenverkehr fließt nun ausschließlich durch den Tunnel — keine eingehenden Ports erforderlich.
  </Step>
</Steps>

<Tip>
  Cloudflare Tunnel ist kostenlos bei allen Plänen, einschließlich Free. Es gibt keine Bandbreiten- oder Datenverkehrsgrenzen.
</Tip>

### Script-Bereitstellung (Bare Metal)

Für Bare-Metal-Server oder benutzerdefinierte Prozessmanager verwenden Sie `./start.sh` direkt:

```bash theme={null}
./start.sh           # production mode
./start.sh portal    # same as above (explicit)
./start.sh api       # API only (headless)
```

In diesem Modus ist Redis **nicht** automatisch enthalten. Das System läuft standardmäßig im Single-Worker-, In-Process-Modus — geeignet für Bereitstellungen mit geringem Datenverkehr.

Um Multi-Worker mit Redis lokal zu aktivieren:

```bash theme={null}
# Start a Redis instance (Docker or system package)
docker run -d --name redis -p 6379:6379 redis:7-alpine

# Add to .env
REDIS_URL=redis://localhost:6379/0
WORKERS=4
DATABASE_URL=postgresql+asyncpg://user:pass@localhost/fim_one
```