# Ouvrir WebUI

Interface élégante de type ChatGPT pour exécuter des LLMs sur les GPU de CLORE.AI.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Pourquoi Open WebUI ?

* **Interface de type ChatGPT** - Interface familière et soignée
* **Multi-modèle** - Basculer facilement entre les modèles
* **RAG intégré** - Téléversez des documents pour le contexte
* **Gestion des utilisateurs** - Prise en charge multi-utilisateurs
* **Historique** - Persistance des conversations
* **Intégration Ollama** - Fonctionne dès la sortie de l’emballage

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
ghcr.io/open-webui/open-webui:cuda
```

**Ports :**

```
22/tcp
8080/http
```

**Commande :**

```bash
# Démarrer Ollama en arrière-plan
ollama serve &
sleep 5
ollama pull llama3.2

# Démarrer Open WebUI (se connecte automatiquement à Ollama)
# Remarque : l'image Docker gère cela
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

### Vérifiez que cela fonctionne

```bash
# Vérifier la santé
curl https://your-http-pub.clorecloud.net/health

# Obtenir la version
curl https://your-http-pub.clorecloud.net/api/version
```

Réponse :

```json
{"version": "0.7.2"}
```

{% hint style="warning" %}
Si vous obtenez HTTP 502, attendez 1-2 minutes - le service est encore en cours de démarrage.
{% endhint %}

## Installation

### Avec Ollama (Recommandé)

```bash
# Démarrer d'abord Ollama
docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# Récupérer un modèle
docker exec -it ollama ollama pull llama3.2

# Démarrer Open WebUI
docker run -d -p 8080:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main
```

### Tout-en-un (Ollama inclus)

```bash
docker run -d -p 8080:8080 \
  --gpus all \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:ollama
```

## Premier démarrage

1. Ouvrir `http://votre-serveur:8080`
2. Créez un compte administrateur (le premier utilisateur devient administrateur)
3. Allez dans Paramètres → Modèles → Télécharger un modèle
4. Commencez à discuter !

## Fonctionnalités

### Interface de discussion

* Rendu Markdown
* Surlignage de code
* Génération d’images (avec modèles compatibles)
* Entrée/sortie vocale
* Pièces jointes de fichiers

### Gestion des modèles

* Télécharger des modèles directement depuis l’interface
* Créer des modèles personnalisés
* Définir le modèle par défaut
* Paramètres spécifiques au modèle

### RAG (Discussion de documents)

1. Cliquez sur "+" dans le chat
2. Téléversez des PDF, TXT ou d’autres documents
3. Posez des questions sur le contenu

### Gestion des utilisateurs

* Utilisateurs multiples
* Contrôle d’accès par rôle
* Gestion des clés API
* Suivi de l’utilisation

## Configuration

### Variables d'environnement

```bash
docker run -d \
  -e OLLAMA_BASE_URL=http://ollama:11434 \
  -e WEBUI_AUTH=True \
  -e WEBUI_NAME="My AI Chat" \
  -e DEFAULT_MODELS="llama3.2" \
  ghcr.io/open-webui/open-webui:main
```

### Paramètres clés

| Variable                | Description                | Par défaut               |
| ----------------------- | -------------------------- | ------------------------ |
| `OLLAMA_BASE_URL`       | URL de l’API Ollama        | `http://localhost:11434` |
| `WEBUI_AUTH`            | Activer l’authentification | `True`                   |
| `WEBUI_NAME`            | Nom de l’instance          | `Ouvrir WebUI`           |
| `DEFAULT_MODELS`        | Modèle par défaut          | -                        |
| `ENABLE_RAG_WEB_SEARCH` | Recherche Web dans RAG     | `False`                  |

### Se connecter à un Ollama distant

```bash
docker run -d -p 8080:8080 \
  -e OLLAMA_BASE_URL=http://remote-server:11434 \
  ghcr.io/open-webui/open-webui:main
```

## Docker Compose

```yaml
version : '3.8'

services :
  ollama:
    image: ollama/ollama
    container_name: ollama
    volumes :
      - ollama:/root/.ollama
    ports :
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    volumes :
      - open-webui:/app/backend/data
    ports :
      - "8080:8080"
    environment :
      - OLLAMA_BASE_URL=http://ollama:11434
    depends_on :
      - ollama

volumes :
  ollama:
  open-webui:
```

```bash
docker-compose up -d
```

## Référence API

Open WebUI fournit plusieurs points de terminaison API :

| Point de terminaison | Méthode | Description                       |
| -------------------- | ------- | --------------------------------- |
| `/health`            | GET     | Vérification de l'état            |
| `/api/version`       | GET     | Obtenir la version d’Open WebUI   |
| `/api/config`        | GET     | Obtenir la configuration          |
| `/ollama/api/tags`   | GET     | Lister les modèles Ollama (proxy) |
| `/ollama/api/chat`   | POST    | Discuter avec Ollama (proxy)      |

### Vérifier la santé

```bash
curl https://your-http-pub.clorecloud.net/health
```

Réponse : `true`

### Obtenir la version

```bash
curl https://your-http-pub.clorecloud.net/api/version
```

Réponse :

```json
{"version": "0.7.2"}
```

### Lister les modèles (via le proxy Ollama)

```bash
curl https://your-http-pub.clorecloud.net/ollama/api/tags
```

{% hint style="info" %}
La plupart des opérations API nécessitent une authentification. Utilisez l’interface web pour créer un compte et gérer les clés API.
{% endhint %}

## Conseils

### Réponses plus rapides

1. Utilisez des modèles quantifiés (Q4\_K\_M)
2. Activez le streaming dans les paramètres
3. Réduisez la longueur du contexte si nécessaire

### Meilleure qualité

1. Utilisez des modèles plus grands (13B+)
2. Utilisez la quantification Q8
3. Ajustez la température dans les paramètres du modèle

### Économiser des ressources

1. Définir `OLLAMA_KEEP_ALIVE=5m`
2. Décharger les modèles inutilisés
3. Utilisez des modèles plus petits pour les tests

## Exigences GPU

Identique à [composant Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md#gpu-requirements).

Open WebUI lui‑même utilise des ressources minimales (\~500 Mo de RAM).

## Dépannage

### Impossible de se connecter à Ollama

```bash
# Vérifiez qu’Ollama est en cours d’exécution
curl http://localhost:11434/api/tags

# Si vous utilisez Docker, utilisez le réseau hôte ou l’URL correcte
docker run --network=host ghcr.io/open-webui/open-webui:main
```

### Les modèles n’apparaissent pas

1. Vérifiez la connexion à Ollama dans les Paramètres
2. Actualisez la liste des modèles
3. Téléchargez des modèles via la CLI : `ollama pull modelname`

### Performance lente

1. Vérifiez que le GPU est utilisé : `nvidia-smi`
2. Essayez des modèles plus petits/quantifiés
3. Réduisez le nombre d’utilisateurs concurrents

## Estimation des coûts

| Configuration    | GPU      | Horaire (Hourly) |
| ---------------- | -------- | ---------------- |
| Basique (7B)     | RTX 3060 | \~$0.03          |
| Standard (13B)   | RTX 3090 | \~$0.06          |
| Avancé (34B)     | RTX 4090 | \~$0.10          |
| Entreprise (70B) | A100     | \~$0.17          |

## Prochaines étapes

* [composant Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) - Utilisation CLI
* [LocalAI](/guides/guides_v2-fr/modeles-de-langage/localai-openai-compatible.md) - Plus de backends
* [RAG + LangChain](/guides/guides_v2-fr/entrainement/finetune-llm.md) - RAG avancé


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/open-webui.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.