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

# Démarrage rapide

> Lancez FIM One en quelques minutes — ou essayez la version cloud instantanément.

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

## Option A : Docker (Recommandé)

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

```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
```

Ouvrez [http://localhost:3000](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 :

```bash theme={null}
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](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
```

| Commande             | Ce qui démarre                                                         | URL                                                               |
| -------------------- | ---------------------------------------------------------------------- | ----------------------------------------------------------------- |
| `./start.sh`         | Next.js + FastAPI                                                      | [http://localhost:3000](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](http://localhost:8000/api)            |
| `./start.sh dev:ui`  | Next.js uniquement, mode développement (HMR)                           | [http://localhost:3000](http://localhost:3000)                    |
| `./start.sh api`     | FastAPI uniquement (sans interface, pour intégration ou tests)         | [http://localhost:8000/api](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](https://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 :

```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
```

Pour une liste complète de toutes les options de configuration, consultez la référence [Variables d'environnement](/configuration/environment-variables).

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

```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
```

#### 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` :

```bash theme={null}
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 :

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

#### Tunnel Cloudflare

Pour une configuration sans ports ouverts, utilisez [Cloudflare Tunnel](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/) à 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.

<Warning>
  **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.
</Warning>

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

**Configuration :**

<Steps>
  <Step title="Créer un tunnel">
    Allez sur [Cloudflare Zero Trust](https://one.dash.cloudflare.com/) → Networks → Tunnels → **Create a tunnel**.
    Choisissez **Cloudflared** comme type de connecteur.
  </Step>

  <Step title="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.

    <Note>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.</Note>
  </Step>

  <Step title="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.
  </Step>

  <Step title="Ajouter le jeton à .env">
    ```bash theme={null}
    # Add to your .env file on the server
    CLOUDFLARE_TUNNEL_TOKEN=eyJhIjoiNj...
    ```
  </Step>

  <Step title="Déployer avec la surcouche tunnel">
    ```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
    ```

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

  <Step title="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.
  </Step>

  <Step title="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.
  </Step>
</Steps>

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

### Déploiement de script (Bare Metal)

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

```bash theme={null}
./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 :

```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
```