> ## Documentation Index > Fetch the complete documentation index at: https://docsmlx.otterly.dev/llms.txt > Use this file to discover all available pages before exploring further. # Disponibilité du modèle > Vérifier proprement si le modèle système Apple est utilisable La disponibilité n'est pas un détail. Avec Foundation Models, votre app peut se lancer sur des appareils où le modèle : * n'est pas pris en charge * n'est pas activé * n'est pas prêt au moment où vous l'appelez Le bon réflexe n'est donc pas de maintenir une liste d'appareils à la main. Il faut **interroger l'API au runtime**. *** ## Vérification la plus simple ```swift theme={null} import FoundationModels if SystemLanguageModel.default.isAvailable { let session = LanguageModelSession() let response = try await session.respond( to: "Donne-moi trois idées d'apps Swift." ) print(response.content) } ``` Cette propriété suffit pour un premier filtrage. Pour une vraie UI, utilisez plutôt `availability`. *** ## Quatre questions différentes Quand vous parlez de "disponibilité", vous mélangez souvent plusieurs sujets. Apple les sépare : | API | La vraie question | | -------------------------------------------- | ----------------------------------------------------- | | `isAvailable` | Le système est-il prêt maintenant ? | | `availability` | Pourquoi n'est-il pas prêt ? | | `supportsLocale(_:)` et `supportedLanguages` | La langue de l'utilisateur est-elle prise en charge ? | | `contextSize` | Combien de contexte le modèle peut-il accepter ? | Gardez cette séparation en tête. Un modèle peut être prêt, mais mal adapté à votre langue ou trop limité pour un long transcript. *** ## Diagnostic détaillé Apple expose un état plus précis via `SystemLanguageModel.default.availability`. ```swift theme={null} import FoundationModels func availabilityMessage() -> String? { switch SystemLanguageModel.default.availability { case .available: return nil case .unavailable(.deviceNotEligible): return "L'appareil ne prend pas en charge Foundation Models." case .unavailable(.appleIntelligenceNotEnabled): return "Apple Intelligence n'est pas activé." case .unavailable(.modelNotReady): return "Le modèle n'est pas prêt pour le moment." case .unavailable: return "Le modèle est indisponible pour une autre raison." } } ``` ### Les cas à connaître | Cas | Ce que ça veut dire | | ------------------------------ | ------------------------------------------------------------------- | | `.available` | Vous pouvez appeler le modèle | | `.deviceNotEligible` | Le matériel ou la configuration ne conviennent pas | | `.appleIntelligenceNotEnabled` | L'utilisateur doit activer la fonctionnalité côté système | | `.modelNotReady` | Le modèle n'est pas prêt maintenant, mais cela peut être temporaire | *** ## Vérifier la langue ou la locale Le support dépend aussi de la langue. ```swift theme={null} import FoundationModels let locale = Locale.current let supported = SystemLanguageModel.default.supportsLocale(locale) print("Locale supportée :", supported) ``` Si votre produit dépend d'une langue précise, faites cette vérification avant d'afficher la fonctionnalité comme disponible. Si vous avez besoin d'un état plus global, `supportedLanguages` vous donne la liste des langues déclarées par le système. `supportsLocale(_:)` reste néanmoins le check le plus direct au runtime. *** ## Disponible ne veut pas dire adapté à votre langue Un appareil peut être techniquement compatible, mais pas votre locale de travail. ```swift theme={null} import FoundationModels let model = SystemLanguageModel.default let locale = Locale(identifier: "fr-FR") if model.isAvailable && model.supportsLocale(locale) { print("La fonctionnalité IA peut être activée.") } else { print("Le modèle est indisponible ou la langue n'est pas prise en charge.") } ``` Pour une app multilingue, ce test évite un faux positif du type "le modèle existe, donc le bouton doit apparaître". *** ## Disponibilité et capacité de contexte `contextSize` répond à une autre question : quelle quantité de contexte le modèle peut accepter, pas si le modèle est prêt. ```swift theme={null} import FoundationModels let maxContextTokens = SystemLanguageModel.default.contextSize print(maxContextTokens) ``` En pratique, un modèle peut être disponible et tout de même refuser une requête parce que votre prompt, vos instructions et votre transcript deviennent trop longs. *** ## Exemple d'UI de fallback ```swift theme={null} import FoundationModels import SwiftUI struct SmartFeatureEntryView: View { private let model = SystemLanguageModel.default var body: some View { switch model.availability { case .available: Text("La fonctionnalité IA est disponible.") case .unavailable(.appleIntelligenceNotEnabled): ContentUnavailableView( "Fonction indisponible", systemImage: "apple.intelligence", description: Text("Activez Apple Intelligence pour utiliser cette fonctionnalité.") ) default: ContentUnavailableView( "Fonction indisponible", systemImage: "exclamationmark.triangle", description: Text("Cette fonctionnalité n'est pas disponible sur cet appareil pour le moment.") ) } } } ``` *** ## Quand vérifier la disponibilité ### Au moment d'afficher la fonctionnalité Utile pour masquer ou désactiver proprement l'entrée dans l'interface. ### Juste avant un appel important Utile si votre vue reste longtemps à l'écran et que l'état a pu changer. ### Au moment de gérer une erreur Si un appel échoue, revérifiez la disponibilité avant d'afficher un message générique. *** ## Recommandation pratique Évitez les phrases du type "disponible à partir de tel appareil" directement dans le code produit. Les règles de disponibilité évoluent plus vite qu'une documentation statique. Votre app doit raisonner avec les états fournis par `SystemLanguageModel`. *** Construire des requêtes plus utiles. Guider le comportement du modèle sur une session.