Schnellstart

☁️ Option 0: Cloud (Keine Einrichtung erforderlich) Möchten Sie nicht selbst hosten? Probieren Sie FIM One sofort unter 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.

Option A: Docker (Empfohlen)

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

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 — 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:

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, Node.js 18+, pnpm.

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 (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
`./start.sh dev:ui`	Nur Next.js, Dev-Modus (HMR)	http://localhost:3000
`./start.sh api`	Nur FastAPI (headless, für Integration oder Tests)	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 ermöglicht Websuche/Abruf, Einbettung und die vollständige RAG-Pipeline (kostenlose Stufe verfügbar). Minimale .env:

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.

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

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:

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:

# 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 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.

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.

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

Einrichtung:

Tunnel erstellen

Gehen Sie zu Cloudflare Zero Trust → Networks → Tunnels → Create a tunnel. Wählen Sie Cloudflared als Connector-Typ.

Ö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.

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

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.

Token zu .env hinzufügen

# Add to your .env file on the server
CLOUDFLARE_TUNNEL_TOKEN=eyJhIjoiNj...

Mit dem Tunnel-Overlay bereitstellen

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.

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.

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.

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

Script-Bereitstellung (Bare Metal)

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

./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:

# 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

Warum FIM One

Erste Schritte

Konfiguration

Integrationen

Funktionen

FIM One erweitern

Option A: Docker (Empfohlen)

Option B: Lokale Entwicklung

Konfiguration

Produktionsbereitstellung

Docker (Empfohlen)

Skalierung mit Workern

Nginx Reverse Proxy

Code Execution Sandbox

Cloudflare Tunnel

Script-Bereitstellung (Bare Metal)

​Option A: Docker (Empfohlen)

​Option B: Lokale Entwicklung

​Konfiguration

​Produktionsbereitstellung

​Docker (Empfohlen)

​Skalierung mit Workern

​Nginx Reverse Proxy

​Code Execution Sandbox

​Cloudflare Tunnel

​Script-Bereitstellung (Bare Metal)

Option A: Docker (Empfohlen)

Option B: Lokale Entwicklung

Konfiguration

Produktionsbereitstellung

Docker (Empfohlen)

Skalierung mit Workern

Nginx Reverse Proxy

Code Execution Sandbox

Cloudflare Tunnel

Script-Bereitstellung (Bare Metal)