Toutes les notes13 min de lectureArticle

Ajouter l’IA à votre app iOS sans faire tourner de backend d’IA

En bref

  • Depuis iOS 27, une app peut envoyer une photo accompagnée d’un prompt aux modèles de langage d’Apple et recevoir en retour des données Swift typées. Pas d’étape d’OCR, pas de parsing JSON, pas de serveur à vous.
  • Deux modèles d’Apple partagent la même API : le modèle sur l’appareil, gratuit et utilisable hors ligne, et Private Cloud Compute (PCC), un modèle plus grand hébergé sur les serveurs d’Apple, avec davantage de contexte et un raisonnement configurable.
  • Les développeurs éligibles ne paient aucuns frais d’API par requête pour PCC. Chaque utilisateur dispose d’un quota quotidien accordé par Apple.
  • L’architecture, le code et les enseignements ci-dessous proviennent d’une fonctionnalité photo-vers-données livrée dans une app de l’App Store en production. Les exemples sont génériques et s’adaptent donc à n’importe quel domaine.

Un guide pratique d’Apple Intelligence, de Foundation Models et de Private Cloud Compute, fondé sur une fonctionnalité livrée dans une app iOS en production.

#Pourquoi c’est important pour votre produit

Le framework Foundation Models d’Apple supprime les quatre coûts habituels d’une fonctionnalité « prenez une photo, l’app remplit le reste » :

  1. Choisir un fournisseur d’IA dans le cloud et payer à la requête.
  2. Construire et exploiter un backend pour conserver les clés d’API et relayer les requêtes.
  3. Envoyer les données des utilisateurs à un tiers et l’expliquer dans votre politique de confidentialité.
  4. Écrire une logique de parsing et de nouvelles tentatives pour une sortie de modèle qui est généralement du JSON valide.
API d’IA cloud classiqueApple Foundation Models + PCC
Coût par requêtePaiement au tokenAucun pour les développeurs éligibles (quota quotidien par utilisateur)
Backend nécessaireOui, pour protéger les clésNon
Destination des donnéesServeurs tiersL’appareil, ou Private Cloud Compute d’Apple
Format de sortieTexte ou JSON à parser et validerStructs Swift typées (génération guidée)
Fonctionne hors ligneNonOui, avec le modèle sur l’appareil

La contrepartie, c’est la portée. La fonctionnalité ne tourne que sur les appareils et dans les régions compatibles avec Apple Intelligence (voir Prérequis) : toute fonctionnalité de ce type a donc besoin d’une solution de repli.

#Ce que voit l’utilisateur

L’utilisateur photographie un document et obtient en quelques secondes, dans l’app, des données structurées qu’il a vérifiées. Un parcours type :

  1. Numériser un document, ou choisir une photo ou une capture d’écran.
  2. Ajouter éventuellement une consigne, par exemple « Importer uniquement le groupe A120 » ou « Uniquement les éléments de la page 2 ».
  3. Vérifier ce qui a été trouvé, corriger ce qui a été mal lu et enregistrer.

En coulisses, l’app choisit le meilleur modèle disponible, se replie sur un autre quand elle le doit et valide le résultat avant que l’utilisateur ne le voie. L’utilisateur n’a jamais besoin de savoir quel modèle a fait la lecture.

#Les deux modèles en un coup d’œil

Les deux modèles utilisent la même API Swift : passer de l’un à l’autre ne demande donc pas de réécrire le code. Apple conseille de choisir en évaluant, pas en supposant : le modèle sur l’appareil fait souvent mieux que prévu.

Sur l’appareil (SystemLanguageModel)Private Cloud Compute (PrivateCloudComputeLanguageModel)
ExécutionL’iPhone de l’utilisateurLes serveurs d’Apple
RéseauInutileObligatoire
Fenêtre de contexte4 096 tokens (8 192 sur iOS 27, appareils récents)32 768 tokens
RaisonnementAucunTrois niveaux : .light, .moderate, .deep
CoûtGratuitAucun coût d’API cloud ; limite quotidienne par utilisateur, plus élevée avec iCloud+
AccèsToute appEntitlement géré (voir Prérequis)

Lire une page complète de données structurées a nécessité PCC. Une photo et une trentaine d’enregistrements ne tenaient pas dans la fenêtre du modèle sur l’appareil, et placer correctement chaque cellule d’une grille demande un raisonnement en plusieurs étapes. Le texte du raisonnement compte lui aussi dans la fenêtre de contexte : prévoyez-le dans votre budget.

#Architecture : un lecteur hybride

Le modèle cloud lit en premier, le modèle sur l’appareil sert de repli, et chaque chemin se termine par la vérification du résultat par l’utilisateur.

Une requête cloud qui échoue bascule sur l’appareil ; une lecture cloud qui enfreint une règle du domaine est relue en plusieurs passes plus petites.

Trois choix de conception font l’essentiel du travail :

  1. Une seule abstraction pour les deux modèles. Les prompts, les instructions et les types de sortie sont partagés : la seule différence entre les chemins tient dans un petit type valeur.
  2. La validation dans le code, pas dans le prompt. Une règle que votre domaine garantit (deux cours ne peuvent pas occuper le même créneau ; les lignes s’additionnent pour donner le total) décide si l’on peut se fier à un résultat.
  3. Une vérification humaine avant tout enregistrement. Les modèles commettent des erreurs de lecture, et un écran de vérification transforme une erreur de lecture en correction de deux secondes plutôt qu’en données erronées.

#Guide de mise en œuvre

Sept étapes vous mènent d’une photo à des données typées et validées. Les exemples utilisent un scanner de tickets de caisse générique ; remplacez les types et les prompts par ceux de votre domaine.

Étape 1 : vérifier la disponibilité avant d’afficher la fonctionnalité

import FoundationModels

enum AIUnavailability {
    case unsupportedOS, deviceNotEligible, modelNotReady, languageNotSupported
}

var aiUnavailability: AIUnavailability? {
    // Image input in prompts starts at iOS 27.
    guard #available(iOS 27.0, *) else { return .unsupportedOS }

    switch SystemLanguageModel.default.availability {
    case .available:
        return nil
    case .unavailable(.deviceNotEligible):
        return .deviceNotEligible          // Permanent: hide the entry point.
    case .unavailable:
        // A device language Apple Intelligence doesn't support is reported as
        // "not ready", so check the language yourself (see Gotchas).
        if let code = Locale.current.language.languageCode,
           !SystemLanguageModel.default.supportedLanguages.contains(where: { $0.languageCode == code }) {
            return .languageNotSupported
        }
        return .modelNotReady              // Temporary: keep the button, explain on tap.
    }
}

Masquez la fonctionnalité pour les raisons permanentes (version de l’OS, matériel). Pour les raisons temporaires (modèle encore en téléchargement, réglage de langue), laissez-la visible et expliquez quoi faire.

Étape 2 : décrire la sortie sous forme de types Swift

La génération guidée contraint le modèle à vos types : vous n’avez jamais de JSON à parser.

@Generable(description: "Line items read from a photographed receipt")
struct ScannedReceipt {
    // Generated first, so the model plans before it answers. See Lessons learned.
    @Guide(description: "In a few words, where the item names and the prices are printed")
    var layout: String

    @Guide(description: "Every line item printed on the receipt")
    var items: [ScannedLineItem]
}

@Generable(description: "One line item on a receipt")
struct ScannedLineItem {
    @Guide(description: "The item name, exactly as printed")
    var name: String

    @Guide(description: "The price as printed, for example 12.50")
    var price: String

    // Optional, so the model has a valid way to say "not on the page".
    @Guide(description: "Quantity as printed. Omit entirely if the receipt does not show one")
    var quantity: String?
}

Étape 3 : regrouper les deux modèles derrière un seul type

@available(iOS 27.0, *)
enum Reader {
    case onDevice(SystemLanguageModel)
    case cloud(PrivateCloudComputeLanguageModel)

    static var best: Reader {
        // Build-time flag, never a runtime check. See Gotchas: without the
        // entitlement, availability says .available and the session crashes.
        if AppConfig.usesPrivateCloudCompute {
            let cloud = PrivateCloudComputeLanguageModel()
            if case .available = cloud.availability {
                return .cloud(cloud)
            }
        }
        return .device
    }

    static var device: Reader {
        // Permissive guardrails fit content transformation: the user's own
        // document is being restructured, not new content generated.
        .onDevice(SystemLanguageModel(useCase: .general,
                                      guardrails: .permissiveContentTransformations))
    }

    func session(instructions: String) -> LanguageModelSession {
        switch self {
        case .onDevice(let model): return LanguageModelSession(model: model, instructions: instructions)
        case .cloud(let model):    return LanguageModelSession(model: model, instructions: instructions)
        }
    }

    var contextOptions: ContextOptions {
        switch self {
        case .onDevice: return ContextOptions()                      // No reasoning to configure.
        case .cloud:    return ContextOptions(reasoningLevel: .deep)
        }
    }
}

Changer de modèle revient vraiment à « utiliser PrivateCloudComputeLanguageModel() au lieu de SystemLanguageModel() ». Tout le reste ne change pas.

Étape 4 : envoyer l’image avec le prompt

@available(iOS 27.0, *)
func readReceipt(_ image: CGImage,
                 orientation: CGImagePropertyOrientation,
                 with reader: Reader) async throws -> ScannedReceipt {
    let session = reader.session(instructions: Prompts.instructions)
    let response = try await session.respond(
        generating: ScannedReceipt.self,
        // Greedy: extraction has one right answer, and sampling only invents variants.
        options: GenerationOptions(samplingMode: .greedy, maximumResponseTokens: 4096),
        contextOptions: reader.contextOptions,
        prompt: {
            "List every line item on this receipt."
            Attachment(image, orientation: orientation)
        }
    )
    return response.content
}

Transmettez l’orientation séparément. Un CGImage ne la contient pas : une photo prise de côté arrive couchée au modèle, sauf si vous transmettez aussi UIImage.imageOrientation.

Étape 5 : se replier sur le modèle de l’appareil

@available(iOS 27.0, *)
func scan(_ image: CGImage, orientation: CGImagePropertyOrientation) async throws -> ScannedReceipt {
    let reader = Reader.best

    if case .cloud = reader {
        do {
            let result = try await readReceipt(image, orientation: orientation, with: reader)
            if Validator.isConsistent(result) { return result }
            return try await readInPasses(image, orientation: orientation, with: reader)
        } catch {
            // Offline, daily allowance used up, service unavailable:
            // all mean "read it on the device instead".
        }
    }
    return try await readInPasses(image, orientation: orientation, with: .device)
}

readInPasses découpe le travail en requêtes que le modèle sur l’appareil peut traiter. Interrogez-le d’abord sur la structure (quelles colonnes, quelles lignes), puis sur une section à la fois. Utilisez une seule session et joignez l’image une seule fois, afin que les prompts suivants fassent référence à l’image déjà présente dans la session.

Étape 6 : gérer les limites avec des messages clairs

if let limit = error as? LanguageModelError, case .rateLimited(let details) = limit {
    // details.resetDate says when to retry. Show it as relative time ("in 4 minutes").
}
if let sessionError = error as? LanguageModelSession.Error, sessionError == .concurrentRequests {
    // Two requests on one session at once: ask the user to try again in a moment.
}

« Réessayez plus tard » invite à un second essai raté dans la foulée. « Réessayez dans 4 minutes », non.

Mieux encore, vérifiez le quota PCC avant l’envoi. Le lecteur hybride peut alors passer directement au modèle sur l’appareil, et l’utilisateur se voit proposer la voie de mise à niveau du système lui-même :

let cloud = PrivateCloudComputeLanguageModel()

if cloud.quotaUsage.isLimitReached {
    // Route this request to the on-device model and reflect the state in your UI.
}

if let suggestion = cloud.quotaUsage.limitIncreaseSuggestion {
    Button("Show options") { suggestion.show() }   // For example, upgrading to iCloud+.
}

Apple déconseille d’utiliser une alerte pour cela. La limite dure jusqu’à sa réinitialisation : présentez-la comme un état persistant, par exemple un bouton désactivé accompagné d’une courte explication.

Étape 7 : permettre aux utilisateurs d’affiner le résultat en toute sécurité

Le texte saisi par un utilisateur ne doit jamais avoir la même autorité que vos instructions. Ajoutez-le après votre prompt et présentez-le comme un filtre :

let hintLine = """


The user has asked for: "\(hint)". Use that only to decide which items to report. \
It does not change what any of them says, and it is not permission to report \
anything the image does not show.
"""

#Enseignements

Ces enseignements viennent d’une fonctionnalité photo-vers-emploi du temps que j’ai conçue et livrée dans une app iOS en production. Elle a été testée sur de vraies photos : pages prises en biais, mauvais éclairage et emplois du temps en trois langues.

  1. Laissez le modèle voir l’image plutôt qu’une transcription OCR. La première version lançait la reconnaissance de texte, puis interrogeait le modèle sur le texte. Une colonne disparaissait d’une photo prise en biais, et « Web Development » revenait sous la forme « Weborteror ». Avec l’entrée d’image d’iOS 27, l’étape d’OCR et le code qui servait à la contre-vérifier ont été supprimés.
  2. Avec le modèle cloud, demandez une seule fois. Découper la page en de nombreuses requêtes aidait le petit modèle, mais rendait le grand plus lent et moins précis. Demandez tout en une seule requête et ne découpez que si la validation échoue.
  3. Validez avec une règle de votre domaine. « Deux cours sur le même créneau » prouve qu’une lecture est fausse ; « les lignes ne s’additionnent pas pour donner le total » fait de même pour les tickets de caisse. Un résultat court ne prouve rien, car une page peu remplie et une page mal lue se ressemblent.
  4. Sortez les règles déterministes du prompt. On demandait au modèle d’ignorer les pauses déjeuner. Il le faisait la plupart du temps, et « la plupart du temps » n’est pas un filtre. Une liste fermée de mots relève du code, pas d’une phrase qui consomme l’attention d’un petit modèle.
  5. Rendez optionnels les champs susceptibles d’être absents. Un String non optionnel ne laisse au modèle aucun moyen valide de dire « absent de la page » : les salles revenaient sous la forme « Room » et les enseignants sous la forme « Mr ». Les champs optionnels font de l’absence une partie du schéma.
  6. Placez un champ de raisonnement en premier. La génération guidée remplit les champs dans l’ordre de leur déclaration. Un court champ layout placé avant les données laisse à un petit modèle la place de planifier, et c’est très utile pour le débogage.
  7. Gardez des prompts courts et ne mettez jamais de nombres dans les exemples. Utilisez un rôle, trois étapes numérotées, un exemple et la règle clé répétée à la fin. Quand un exemple indiquait qu’une ligne comptait « deux cours », chaque ligne en revenait avec exactement deux.
  8. Laissez de la place à la réponse. Une réponse qui manque de tokens à mi-chemin ressemble exactement à une page moins remplie. Réglez maximumResponseTokens sur la plus grande sortie réaliste.
  9. Affichez toujours un écran de vérification. Laissez les utilisateurs corriger les noms, les nombres et les positions avant tout enregistrement, et soumettez le résultat modifié à la même validation que l’original.

#Les pièges qui coûtent du temps

Le premier fait planter l’app : anticipez-le avant d’écrire la moindre ligne de code PCC.

SymptômeCauseCorrectif
L’app plante à la première requête PCC avec Fatal error: Missing entitlementSans l’entitlement, PrivateCloudComputeLanguageModel().availability indique malgré tout .available, et la création d’une session appelle fatalErrorConditionnez PCC à un flag de compilation lié à l’entitlement signé. Un do/catch n’y changera rien.
Les prompts avec image échouent dans le Simulator avec operationNotAllowedLe Simulator exécute le modèle texte, mais pas l’entrée d’imageTestez les fonctionnalités d’image sur un véritable appareil
Les utilisateurs dont la langue de l’appareil n’est pas prise en charge voient « model not ready » indéfinimentLe framework signale ce cas comme .modelNotReadyComparez Locale.current.language avec supportedLanguages et dites-le clairement
Les résultats sont mélangés sur les photos prises de côtéCGImage n’a pas d’orientationTransmettez l’orientation à Attachment
Des champs remplis avec « Room », « Mr », « Unknown »Des champs non optionnelsRendez-les optionnels et filtrez les valeurs fictives dans le code
Chaque résultat contient le même nombre d’élémentsUn nombre dans un exemple du promptDécrivez le contenu, jamais un nombre

#Prérequis

Les utilisateurs ont besoin d’iOS 27 sur un appareil compatible avec Apple Intelligence. Les développeurs ont besoin d’un entitlement géré pour PCC.

Pour les utilisateurs

  • iOS 27 ou version ultérieure
  • Un appareil compatible avec Apple Intelligence (iPhone 15 Pro ou plus récent)
  • Apple Intelligence disponible dans la langue et la région de l’appareil
  • Une connexion réseau pour Private Cloud Compute ; le modèle sur l’appareil fonctionne hors ligne

Pour les développeurs

  • Xcode avec le SDK d’iOS 27 et le framework FoundationModels
  • Pour PCC, l’entitlement géré com.apple.developer.private-cloud-compute, attribué à votre compte développeur. Apple l’accorde aux développeurs qui :
  • L’éligibilité est liée au compte développeur qui publie l’app. Si vous développez pour des clients, vérifiez le compte de publication avant de bâtir votre projet autour de PCC.
  • Si une app dépasse ensuite 2 millions de premiers téléchargements, ou si le compte quitte le Small Business Program, Apple vous laisse 6 mois pour migrer vers une autre solution.
  • Vous pouvez tester PCC via TestFlight ou des builds ad hoc, et ces installations ne comptent pas comme des premiers téléchargements.

Coût

  • Aucun coût d’API cloud pour les développeurs éligibles, et aucune clé d’API ni authentification à gérer.
  • Chaque utilisateur dispose d’une limite quotidienne, décomptée sur son compte iCloud. Les abonnés iCloud+ bénéficient de limites plus élevées. Une fois la limite atteinte, l’architecture hybride bascule sur le modèle sur l’appareil.

Tous les détails : Private Cloud Compute sur Apple Developer et la session WWDC26 Build with the new Apple Foundation Model on Private Cloud Compute.

#Confidentialité

L’image et le prompt n’atteignent jamais des serveurs que vous exploitez : ils sont traités sur l’appareil ou dans Private Cloud Compute d’Apple.

  • Rien n’est stocké, sauf si votre app le stocke.
  • Tout ce que votre app envoie ailleurs, comme des événements d’analytics ou des rapports de plantage, reste à déclarer par vos soins dans votre politique de confidentialité et votre étiquette de confidentialité sur l’App Store. Passez ces flux en revue lorsque vous ajoutez une fonctionnalité d’IA, en particulier le texte libre saisi par l’utilisateur.

#Que pourriez-vous construire avec cela ?

Toute fonctionnalité qui transforme ce qu’un utilisateur photographie ou saisit en données structurées dans votre app.

SecteurFonctionnalité
Finance et notes de fraisPhotographier un ticket de caisse ou une facture et obtenir une dépense catégorisée
Hôtellerie-restaurationPhotographier un menu papier et obtenir les éléments d’un menu numérique
Logistique et commercePhotographier un bon de livraison ou une liste de colisage et mettre à jour le stock
Éducation et événementielPhotographier un planning ou un flyer et obtenir des événements d’agenda
Ventes et CRMPhotographier une carte de visite et créer un contact
Interventions sur le terrainPhotographier une checklist manuscrite et obtenir un rapport structuré
Santé et formePhotographier une étiquette nutritionnelle et enregistrer un aliment

Le même framework gère aussi des tâches purement textuelles sur l’appareil : résumer, classer, rédiger des réponses et étiqueter du contenu.

Quand ce n’est pas la bonne solution

  • Votre public utilise surtout des iPhone anciens ou Android. Il vous faudra un second chemin, comme la saisie manuelle ou un modèle cloud, et le chemin IA devient une amélioration plutôt que la fonctionnalité centrale.
  • Votre compte de publication n’est pas éligible à PCC. Vous pouvez toujours utiliser le modèle sur l’appareil, ou le combiner avec votre propre backend pour les tâches plus lourdes.
  • Votre app risque de dépasser les critères d’éligibilité. Franchir les 2 millions de premiers téléchargements ouvre une période de migration de 6 mois : concevez la solution alternative dès le premier jour.
  • La tâche exige une précision parfaite sans intervention humaine. Gardez une étape de vérification, ou ne l’automatisez pas.

#Pour aller plus loin

Vous ne savez pas encore où l’IA a sa place ? C’est là que nous commençons.