Démarrage rapide

☁️ Option 0 : Cloud (Configuration zéro) Vous ne voulez pas auto-héberger ? Essayez FIM One instantanément sur cloud.fim.ai — pas de Docker, pas de clés API, pas de configuration. Connectez-vous et vous êtes prêt. Accès anticipé.

Option A : Docker (Recommandé)

Aucun Python ou Node.js local requis — tout est construit à l’intérieur du conteneur.

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

Ouvrez http://localhost:3000 — au premier lancement, vous serez guidé pour créer un compte administrateur. C’est tout. Après la construction initiale, les démarrages suivants ne nécessitent que :

docker compose up -d          # start (skip rebuild if image unchanged)
docker compose down           # stop
docker compose logs -f        # view logs

Les données sont conservées dans les volumes nommés Docker (fim-data, fim-uploads) et survivent aux redémarrages du conteneur. Remarque : Le mode Docker ne supporte pas le rechargement à chaud. Les modifications du code nécessitent de reconstruire l’image (docker compose up --build -d). Pour un développement actif avec rechargement en direct, utilisez Option B ci-dessous.

Option B : Développement local

Prérequis : 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

Commande	Ce qui démarre	URL
`./start.sh`	Next.js + FastAPI	http://localhost:3000 (UI) + :8000 (API)
`./start.sh dev`	Identique, avec rechargement à chaud (Python `--reload` + Next.js HMR)	Identique
`./start.sh dev:api`	API uniquement, mode développement (`--reload`)	http://localhost:8000/api
`./start.sh dev:ui`	Next.js uniquement, mode développement (HMR)	http://localhost:3000
`./start.sh api`	FastAPI uniquement (sans interface, pour intégration ou tests)	http://localhost:8000/api

Configuration

FIM One fonctionne avec n’importe quel fournisseur de LLM compatible avec OpenAI — OpenAI, DeepSeek, Anthropic, Qwen, Ollama, vLLM, et bien d’autres.

Fournisseur	`LLM_API_KEY`	`LLM_BASE_URL`	`LLM_MODEL`
OpenAI	`sk-...`	(par défaut)	`gpt-4o`
DeepSeek	`sk-...`	`https://api.deepseek.com/v1`	`deepseek-chat`
Anthropic	`sk-ant-...`	`https://api.anthropic.com/v1`	`claude-sonnet-4-6`
Ollama (local)	`ollama`	`http://localhost:11434/v1`	`qwen2.5:14b`

Jina AI déverrouille la recherche/récupération web, l’intégration vectorielle et le pipeline RAG complet (niveau gratuit disponible). Fichier .env minimal :

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

Pour une liste complète de toutes les options de configuration, consultez la référence Variables d’environnement.

Déploiement en production

Docker (Recommandé)

docker compose up -d démarre tout ce dont vous avez besoin — aucune configuration manuelle de service requise :

Service	Objectif	Configuré par
fim-one	API + Frontend	`.env` (vos clés LLM, etc.)
Redis	Relais d’interruption inter-workers	Auto-configuré par 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

Mise à l’échelle avec des Workers

Par défaut, l’API s’exécute avec un seul processus worker. Pour gérer plus d’utilisateurs simultanés, augmentez les workers via .env :

WORKERS=4   # number of Uvicorn worker processes

Exigences multi-worker :

PostgreSQL — SQLite est single-writer et ne supporte pas les écritures concurrentes. Définissez DATABASE_URL sur une chaîne de connexion PostgreSQL.
Redis — déjà inclus dans Docker Compose (auto-configuré). Gère le relais d’interruption/injection entre workers.

Avec WORKERS=1 (par défaut), Redis ou PostgreSQL ne sont pas nécessaires — SQLite fonctionne bien.

Proxy inverse Nginx

Pour HTTPS et un domaine personnalisé, placez un proxy inverse Nginx devant :

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

L’API s’exécute en interne sur le port 8000 — Next.js proxifie automatiquement les requêtes /api/*. Seul le port 3000 doit être exposé.

Bac à sable d’exécution de code

Si vous utilisez le bac à sable d’exécution de code (CODE_EXEC_BACKEND=docker), montez le socket Docker :

# docker-compose.yml
volumes:
  - /var/run/docker.sock:/var/run/docker.sock

Tunnel Cloudflare

Pour une configuration sans ports ouverts, utilisez Cloudflare Tunnel à la place de Nginx. Tout le trafic transite par les serveurs périphériques de Cloudflare — pas besoin d’exposer les ports 80/443, de gérer les certificats SSL ou de configurer les règles de pare-feu.

Utilisateurs de la Chine continentale : Les plans Cloudflare Free/Pro/Business n’ont pas de PoP (Points-of-Presence) en Chine continentale. Le trafic en provenance de la Chine continentale est acheminé vers des serveurs périphériques à l’étranger (généralement US West), ce qui provoque des erreurs 502 fréquentes et une latence élevée. N’utilisez pas Cloudflare Tunnel si vos utilisateurs principaux sont en Chine continentale. Cloudflare Enterprise avec China Network (partenariat JD Cloud) est nécessaire pour un accès fiable en Chine continentale.

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

Configuration :

Créer un tunnel

Allez sur Cloudflare Zero Trust → Networks → Tunnels → Create a tunnel. Choisissez Cloudflared comme type de connecteur.

Configurer le nom d'hôte public

Dans la configuration du tunnel, ajoutez un nom d’hôte public :

Champ	Valeur
Type	`HTTP`
URL	`fim-one:3000`

Laissez tous les autres paramètres (HTTP Host Header, Chunked Encoding, Timeouts, Access) à leurs valeurs par défaut.

L’URL utilise le nom du service Docker fim-one, pas localhost, car cloudflared s’exécute en tant que conteneur séparé dans le même réseau Docker.

Copier le jeton du tunnel

Sur la page Configure du tunnel, trouvez la commande d’installation — elle contient un jeton commençant par eyJ.... Copiez-le.

Ajouter le jeton à .env

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

Déployer avec la surcouche tunnel

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

La surcouche docker-compose.tunnel.yml ajoute un conteneur sidecar cloudflared. Le fichier docker-compose.yml de base reste inchangé — les utilisateurs de la communauté sans Cloudflare peuvent continuer à utiliser docker compose up -d comme avant.

Supprimer l'ancien enregistrement DNS

Si votre domaine avait précédemment un enregistrement A pointant vers l’adresse IP de votre serveur, supprimez-le dans le DNS Cloudflare. Le tunnel crée automatiquement un enregistrement CNAME pointant vers son point de terminaison périphérique.

Fermer les ports du serveur

Supprimez (ou commentez) la section ports de docker-compose.yml sur votre serveur. Le trafic transite maintenant exclusivement par le tunnel — aucun port entrant n’est nécessaire.

Cloudflare Tunnel est gratuit sur tous les plans, y compris le plan Free. Il n’y a pas de limites de bande passante ou de trafic.

Déploiement de script (Bare Metal)

Pour les serveurs bare-metal ou les gestionnaires de processus personnalisés, utilisez ./start.sh directement :

./start.sh           # production mode
./start.sh portal    # same as above (explicit)
./start.sh api       # API only (headless)

Dans ce mode, Redis n’est pas inclus automatiquement. Le système s’exécute en mode single-worker, in-process par défaut — adapté aux déploiements à faible trafic. Pour activer le multi-worker avec Redis localement :

# 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

Pourquoi FIM One