> ## Documentation Index
> Fetch the complete documentation index at: https://docs.apimart.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Utiliser APIMart dans Dify
> Guide détaillé sur la façon de configurer et d'utiliser le service API APIMart dans la plateforme LLMOps Dify. Ce guide vous aidera à configurer l'API APIMart dans Dify pour construire de puissantes applications IA.
## Prérequis
Avant de commencer, assurez-vous que :
1. **Compte Dify enregistré**
Visitez le [site officiel de Dify](https://dify.ai/) pour enregistrer un compte, choisissez la version cloud ou auto-hébergée
2. **Clé API APIMart obtenue**
Connectez-vous à la [console APIMart](https://apimart.ai/keys) pour obtenir votre clé API (commence par `sk-`)
**Astuce :** si vous n'avez pas encore de compte APIMart, inscrivez-vous d'abord sur [APIMart](https://apimart.ai) et obtenez une clé API.
## Étape 1 : Se connecter à Dify et accéder aux paramètres
### 1.1 Accéder à la plateforme Dify
* **Version cloud :** visitez [https://cloud.dify.ai](https://cloud.dify.ai) et connectez-vous
* **Version auto-hébergée :** visitez l'adresse de votre déploiement Dify
*Interface principale de Dify montrant la liste des applications et le bouton de création*
### 1.2 Accéder aux paramètres de modèle
1. Cliquez sur l'**icône d'avatar** en haut à droite
2. Sélectionnez **Settings**
3. Choisissez **Model Provider** dans le menu de gauche
*Trouvez l'option « Model Provider » dans le menu de gauche*
**Remarque :** Dify prend en charge la configuration de plusieurs fournisseurs de modèles. Vous pouvez utiliser APIMart aux côtés d'autres fournisseurs.
## Étape 2 : Ajouter le fournisseur de modèles APIMart
**Méthodes de configuration :** il existe deux façons de configurer APIMart dans Dify :
**Méthode 1 (recommandée) :** utiliser la fonction Custom API du fournisseur OpenAI
* Dans les paramètres du fournisseur OpenAI, modifiez directement la Base URL en `https://api.apimart.ai/v1`
* Saisissez votre clé API APIMart
* Configuration plus rapide et simple
**Méthode 2 :** ajouter en tant que fournisseur de modèle personnalisé (méthode de ce guide)
* Plus flexible, peut gérer séparément le fournisseur APIMart
* Pratique pour utiliser plusieurs fournisseurs d'API simultanément
Les deux méthodes sont fonctionnellement identiques. Choisissez selon votre préférence.
### 2.1 Sélectionner la méthode de configuration
#### Méthode 1 : utiliser OpenAI Custom API (recommandée)
1. Trouvez le fournisseur **OpenAI** sur la page Model Provider
2. Cliquez sur le bouton **Configure** ou **Settings**
3. Sur la page de configuration :
* **API Key** : saisissez votre clé API APIMart (`sk-xxxxxxxxxxxx`)
* **API Base URL** ou **Base URL** : saisissez `https://api.apimart.ai/v1`
4. Cliquez sur **Save**
*Configurez la clé API et la Base URL d'APIMart dans le fournisseur OpenAI*
5. Après la configuration, revenez à la page du fournisseur OpenAI et consultez la **Model List**
6. Dans la liste des modèles, trouvez les modèles dont vous avez besoin (par ex. `gpt-4o`, `gpt-4o-mini`, `chatgpt-4o-latest`, etc.)
7. Cliquez sur le **commutateur** à droite du modèle pour l'activer (bleu indique activé)
*Activez les modèles dont vous avez besoin dans la liste des modèles OpenAI*
**Important :** n'activez que les modèles réellement pris en charge par APIMart !
Bien que la liste des modèles OpenAI de Dify affiche de nombreux modèles, seuls ceux pris en charge par APIMart fonctionneront correctement. Activer des modèles non pris en charge causera des échecs d'appels API.
Veuillez consulter la [documentation API d'APIMart](https://docs.apimart.ai) pour la liste complète des modèles pris en charge.
**Modèles pris en charge et recommandés par APIMart :**
**Série GPT :**
* `gpt-5` / `gpt-5-chat-latest` — modèles de la série GPT-5
* `chatgpt-4o-latest` / `gpt-4o` — dernier modèle GPT-4o
* `gpt-4o-mini` — version rapide et économique
* `gpt-4.1` / `gpt-4.1-mini` — série GPT-4.1
**Série Claude :**
* `claude-sonnet-4-5-20250929` — Claude Sonnet 4.5
* `claude-haiku-4-5-20251001` — Claude Haiku 4.5
**Série Gemini :**
* `gemini-2.0-flash-exp` — Google Gemini 2.0 Flash
Vous pouvez activer plusieurs modèles simultanément et basculer entre eux de manière flexible dans vos applications.
Une fois terminé, vous pouvez l'utiliser directement. Passez à l'**Étape 3**.
#### Méthode 2 : ajouter un fournisseur de modèle personnalisé
Sur la page Model Provider :
1. Faites défiler vers le bas jusqu'à la section **Custom Model**
2. Cliquez sur le bouton **+ Add Model**
*Faites défiler jusqu'à la section des modèles personnalisés et cliquez sur le bouton « + Add Model »*
### 2.2 Configurer le fournisseur APIMart
Dans la boîte de dialogue de configuration, remplissez les informations suivantes :
| Champ | Valeur |
| ----------------------- | ----------------------------------------------------------------------------------------------------------- |
| **Model Name** | `APIMart` ou nom personnalisé |
| **Model Type** | sélectionner `LLM` (Large Language Model) |
| **API Key** | votre clé API APIMart (`sk-xxxxxxxxxxxx`) |
| **API endpoint URL** | `https://api.apimart.ai/v1` |
| **Endpoint model name** | saisissez le nom du modèle spécifique (par ex. `gpt-4o`, `gpt-4o-mini`, `claude-sonnet-4-5-20250929`, etc.) |
*Remplissez la configuration du fournisseur APIMart*
**Important :**
* La Base URL doit inclure le suffixe `/v1` : `https://api.apimart.ai/v1`
* La clé API doit être obtenue depuis la console APIMart et commencer par `sk-`
* Assurez-vous que votre clé API dispose d'un solde suffisant
### 2.3 Ajouter plus de modèles (optionnel)
Pour ajouter plus de modèles, répétez les étapes ci-dessus :
1. Dans la section des modèles personnalisés, cliquez à nouveau sur **+ Add Model**
2. Remplissez les informations de configuration pour un autre modèle
3. Cliquez sur Save
*Répétez les étapes pour configurer plusieurs modèles différents*
**Modèles recommandés à ajouter :**
#### Série GPT-4/5
| ID du modèle | Nom du modèle | Longueur du contexte | Cas d'utilisation |
| ------------- | ------------- | -------------------- | ------------------------------------------ |
| `gpt-5` | GPT-5 | 128 000 | Tâches complexes, traitement de texte long |
| `gpt-4o` | GPT-4o | 128 000 | Chat de haute qualité, génération de code |
| `gpt-4o-mini` | GPT-4o Mini | 128 000 | Réponse rapide, économique |
#### Série Claude
| ID du modèle | Nom du modèle | Longueur du contexte | Cas d'utilisation |
| ---------------------------- | ----------------- | -------------------- | -------------------------------------- |
| `claude-sonnet-4-5-20250929` | Claude Sonnet 4.5 | 200 000 | Raisonnement complexe, analyse de code |
| `claude-haiku-4-5-20251001` | Claude Haiku 4.5 | 200 000 | Réponse rapide, tâches simples |
#### Série Gemini
| ID du modèle | Nom du modèle | Longueur du contexte | Cas d'utilisation |
| ---------------------- | ---------------- | -------------------- | ----------------------------------- |
| `gemini-2.0-flash-exp` | Gemini 2.0 Flash | 32 000 | Multimodal, applications temps réel |
**Recommandations de performance :**
* 💰 **Économique :** `gpt-4o-mini`, `claude-haiku-4-5-20251001`
* 🚀 **Haute performance :** `gpt-5`, `gpt-4o`, `claude-sonnet-4-5-20250929`
* ⚡ **Réponse rapide :** `gemini-2.0-flash-exp`, `gpt-4o-mini`
## Étape 3 : Utiliser les modèles APIMart dans les applications
### 3.1 Créer une nouvelle application
1. Revenez à la page d'accueil de Dify
2. Cliquez sur le bouton **Create App**
3. Sélectionnez le type d'application :
* **Chatbot** — application conversationnelle
* **Text Generator** — application de génération de texte
* **Agent** — agent intelligent
* **Workflow** — application de workflow complexe
*Sélectionner le type d'application pour créer une nouvelle app*
### 3.2 Sélectionner le modèle APIMart
Sur la page d'orchestration de l'application :
1. Trouvez la zone **Model Settings**
2. Cliquez sur le menu déroulant **Select Model**
3. Sélectionnez le fournisseur **APIMart**
4. Choisissez votre modèle configuré (par ex. `gpt-4o`)
*Sélectionnez le modèle du fournisseur APIMart dans l'application*
### 3.3 Configurer les paramètres du modèle
Ajustez les paramètres du modèle selon les besoins :
| Paramètre | Description | Valeur recommandée |
| --------------------- | --------------------------------- | ---------------------------- |
| **Temperature** | contrôle l'aléatoire de la sortie | 0,7 (créatif) / 0,3 (précis) |
| **Max Tokens** | longueur maximale de sortie | 2000-4000 |
| **Top P** | paramètre de nucleus sampling | 0,9 |
| **Presence Penalty** | réduit les répétitions | 0,0-0,5 |
| **Frequency Penalty** | réduit les mots fréquents | 0,0-0,5 |
*Ajustez les paramètres du modèle selon les besoins de l'application*
## Étape 4 : Construire et tester l'application
### 4.1 Ajouter des prompts
Sur la page d'orchestration de l'application :
1. Écrivez les prompts dans la zone **System Prompt**
2. Utilisez des variables pour rendre votre app dynamique :
* `{{variable_name}}` — variable d'entrée utilisateur
* `{{context}}` — contexte de la base de connaissances
**Prompt d'exemple :**
```
You are a professional customer service assistant, skilled at answering product questions.
Product Information: {{product_info}}
Please provide accurate and friendly answers based on user questions. If unsure, honestly inform the user.
User Question: {{user_question}}
```
*Écrivez et configurez les prompts dans l'éditeur de prompts*
### 4.2 Ajouter une base de connaissances (optionnel)
Si vous avez besoin de la capacité RAG (Retrieval Augmented Generation) :
1. Cliquez sur **Knowledge Base** dans le menu de gauche
2. Créez une nouvelle base de connaissances et téléversez des documents
3. Liez la base de connaissances sur la page d'orchestration de l'application
4. Configurez les paramètres de recherche
### 4.3 Tester l'application
1. Saisissez des questions de test dans le panneau **Preview** à droite
2. Examinez l'efficacité de la réponse de l'IA
3. Ajustez les prompts et les paramètres selon les besoins
4. Répétez le test jusqu'à satisfaction
*Testez l'efficacité de l'application dans le panneau d'aperçu*
### 4.4 Publier l'application
Après le test :
1. Cliquez sur le bouton **Publish** en haut à droite
2. Sélectionnez la méthode de publication :
* **API Call** — intégration via API
* **Embed in Website** — générer le code d'intégration
* **Public Link** — générer un lien de partage
*Sélectionnez la méthode de publication appropriée*
## Étape 5 : Surveiller et optimiser
### 5.1 Consulter les journaux de l'application
Sur la page de détails de l'application :
1. Cliquez sur l'onglet **Logs**
2. Consultez tous les enregistrements de conversation
3. Analysez les questions utilisateur et les réponses de l'IA
4. Découvrez les opportunités d'amélioration
*Consultez et analysez les journaux d'utilisation de l'application*
### 5.2 Surveiller l'utilisation de l'API
Connectez-vous à la [console APIMart](https://apimart.ai/overview) pour voir :
* 📊 **Statistiques d'appels API** — total des appels, taux de succès
* 💰 **Détails des coûts** — coûts journaliers/mensuels
* 📈 **Tendances d'utilisation** — tendances de changement
* 🔍 **Journaux des requêtes** — enregistrements détaillés des requêtes
### 5.3 Optimiser les performances de l'application
Optimisez sur la base des données de surveillance :
1. **Ajuster la sélection du modèle**
* Utilisez `gpt-4o-mini` pour les tâches simples afin de réduire les coûts
* Utilisez `gpt-4o` ou `claude-sonnet-4-5` pour les tâches complexes afin d'améliorer la qualité
2. **Optimiser les prompts**
* Rendre les prompts plus clairs et spécifiques
* Ajouter des exemples pour améliorer l'efficacité
* Utiliser chain-of-thought pour un meilleur raisonnement
3. **Configurer la mise en cache**
* Activer la mise en cache pour les questions similaires
* Réduire les coûts d'appel API
## Fonctionnalités avancées
### Utiliser l'orchestration de workflow
La fonctionnalité workflow de Dify vous permet de :
1. **Branches conditionnelles** — exécuter une logique différente selon les conditions
2. **Collaboration multi-modèles** — combiner les avantages de plusieurs modèles
3. **Appels d'outils externes** — appeler des API, bases de données et autres ressources externes
4. **Passage de variables** — passer des données entre différents nœuds
### Configurer les capacités d'agent
Construisez des agents intelligents avec les modèles APIMart :
1. **Appel d'outils** — laisser l'IA appeler des outils externes
2. **Gestion de la mémoire** — maintenir une mémoire de conversation à long terme
3. **Prise de décision autonome** — l'IA planifie de manière autonome les étapes d'exécution
### Applications multimodales
Exploitez les capacités multimodales d'APIMart :
1. **Compréhension d'images** — utilisez `gpt-4o` ou `claude-3` pour traiter les images
2. **Génération d'images** — intégrez l'API de génération d'images d'APIMart
3. **Traitement vocal** — intégrez les services TTS et STT
## FAQ
### Q1 : Impossible de se connecter au service APIMart ?
**Solution :**
1. **Vérifier la Base URL** :
* Assurez-vous qu'il s'agit de `https://api.apimart.ai/v1` (inclut `/v1`)
* N'ajoutez pas de chemins supplémentaires et n'omettez pas `/v1`
2. **Vérifier la clé API** :
* Confirmez que la clé API commence par `sk-`
* Vérifiez si la clé est valide dans la [console APIMart](https://apimart.ai/keys)
3. **Vérifier la connexion réseau** :
* Assurez-vous que le serveur peut accéder à `https://api.apimart.ai`
* Les versions auto-hébergées doivent assurer la connectivité réseau du serveur
### Q2 : La réponse du modèle est lente ?
**Solution :**
1. **Passer à des modèles plus rapides** :
* Utilisez `gpt-4o-mini` au lieu de `gpt-4o`
* Utilisez `gemini-2.0-flash-exp` pour une réponse plus rapide
2. **Optimiser la longueur des prompts** :
* Réduisez le contexte inutile
* Simplifiez les descriptions des prompts
3. **Ajuster la recherche dans la base de connaissances** :
* Réduisez le nombre de documents récupérés
* Augmentez le seuil de similarité
### Q3 : Les appels API échouent ou renvoient des erreurs ?
**Erreurs courantes et solutions :**
| Message d'erreur | Cause | Solution |
| --------------------------- | ---------------------------------------- | ---------------------------------------------------------------------------------- |
| `401 Unauthorized` | Clé API invalide ou expirée | Récupérez à nouveau la clé API et mettez à jour la configuration |
| `429 Too Many Requests` | Limite de débit dépassée | Ajustez les paramètres de concurrence de l'app ou attendez et réessayez |
| `500 Internal Server Error` | Problème temporaire du serveur | Attendez quelques minutes et réessayez |
| `insufficient_quota` | Solde de compte insuffisant | Rechargez dans la console |
| `context_length_exceeded` | L'entrée dépasse la longueur du contexte | Réduisez la longueur de l'entrée ou utilisez un modèle avec un contexte plus large |
### Q4 : Comment réduire les coûts d'utilisation de l'API ?
**Suggestions d'optimisation des coûts :**
1. **Sélection du modèle** :
* Utilisez `gpt-4o-mini` pour les tâches simples (le coût n'est que 1/10 de `gpt-4o`)
* Envisagez des modèles plus économiques pour les tâches par lots
2. **Activer la mise en cache** :
* Retournez les résultats en cache pour les mêmes questions
* Configurez la correspondance par similarité dans Dify
3. **Optimiser la longueur de sortie** :
* Définissez des Max Tokens raisonnables
* Évitez de générer des réponses trop longues
4. **Utiliser la sortie en streaming** :
* Améliore l'expérience utilisateur sans augmenter les coûts
### Q5 : Comment gérer les données sensibles ?
**Recommandations de sécurité des données :**
1. **Utiliser des variables d'environnement** :
* Ne codez pas en dur les clés API dans le code
* Utilisez la fonctionnalité de variables d'environnement de Dify
2. **Configurer le contrôle d'accès** :
* Définissez les permissions d'accès à l'application
* Activez l'authentification pour les appels API
3. **Journaux d'audit** :
* Vérifiez régulièrement les journaux de l'application
* Surveillez les modèles d'accès anormaux
## Bonnes pratiques
### 1. Ingénierie de prompts
**Prompts structurés :**
```
# Role Definition
You are a professional [role description]
# Task Objective
You need to help users [task description]
# Output Requirements
- Requirement 1
- Requirement 2
- Requirement 3
# Input Information
{{user_input}}
```
### 2. Gestion de la base de connaissances
* **Stratégie de découpage** : définir une taille de chunk de document raisonnable (recommandé 500-1000 caractères)
* **Étiquetage de métadonnées** : ajouter des métadonnées aux documents pour faciliter la recherche
* **Mises à jour régulières** : maintenir le contenu de la base de connaissances à jour
### 3. Gestion des erreurs
* **Messages conviviaux** : fournir des messages d'erreur clairs aux utilisateurs
* **Stratégie de repli** : basculer vers un modèle de secours en cas d'échec du principal
* **Mécanisme de nouvelle tentative** : nouvelle tentative automatique pour les erreurs temporaires
### 4. Surveillance des performances
* **Définir des alertes** : alertes pour solde faible, taux d'erreur élevés
* **Analyse régulière** : analyser les données d'utilisation hebdomadairement/mensuellement
* **Optimisation continue** : ajuster la configuration sur la base des données
## Exemples de cas d'utilisation
### 1. Service client intelligent
**Configuration d'application :**
* Modèle : `gpt-4o-mini` (économique)
* Base de connaissances : documents produit, FAQ
* Fonctionnalités : réponse automatique aux questions courantes, escalade des problèmes complexes vers l'humain
### 2. Assistant de création de contenu
**Configuration d'application :**
* Modèle : `gpt-4o` ou `claude-sonnet-4-5` (haute qualité)
* Fonctionnalités : génération d'articles, réécriture, polissage
* Paramètres : Temperature=0,8 (renforce la créativité)
### 3. Assistant de code
**Configuration d'application :**
* Modèle : `claude-sonnet-4-5` (excellent pour le code)
* Fonctionnalités : génération, explication, débogage de code
* Base de connaissances : docs du projet, docs API
### 4. Assistant d'analyse de données
**Configuration d'application :**
* Modèle : `gpt-4o` (forte capacité de raisonnement)
* Outils : exécution de code Python, visualisation de données
* Fonctionnalités : analyse de données, génération de rapports
## Fonctionnalités
En utilisant Dify + APIMart, vous pouvez :
* 🤖 **Construire rapidement des apps IA** — créer de puissantes applications IA sans codage
* 📚 **Enrichissement par base de connaissances** — la technologie RAG laisse l'IA répondre sur la base de vos données
* 🔧 **Workflows flexibles** — orchestrer visuellement la logique IA complexe
* 🎯 **Gestion précise des prompts** — contrôle de version et tests A/B
* 📊 **Surveillance et analyses complètes** — comprendre l'utilisation et la performance de l'app
* 🔌 **Plusieurs méthodes d'intégration** — API, intégré, WebApp et plus
* 👥 **Collaboration d'équipe** — support du développement multi-utilisateur
* 🌐 **Support multi-modèles** — basculer de manière flexible entre différents modèles d'IA
## Support et aide
Si vous rencontrez des problèmes :
* 📚 [Documentation APIMart](https://docs.apimart.ai)
* 📚 [Documentation officielle Dify](https://docs.dify.ai)
* 💬 [Communauté Discord](https://discord.gg/V8zqssyZ5c)
* 🐦 [Twitter @APIMart\_](https://x.com/APIMart_)
* 📧 Support technique : [zhihong@apimart.ai](mailto:zhihong@apimart.ai)
***
Inscrivez-vous à APIMart maintenant, obtenez votre clé API et construisez de puissantes applications IA dans Dify !