FoundationModels : comprendre et utiliser le nouveau framework IA d'Apple

Un nouveau paradigme pour l'IA sur iOS

Apple a dévoilé un framework qui transforme la manière d'intégrer l'intelligence artificielle dans les applications iOS : FoundationModels. Contrairement aux solutions cloud comme OpenAI ou Anthropic, Apple a choisi une voie radicalement différente. Aucune requête envoyée à un serveur externe : tout s'exécute localement sur l'appareil, en s'appuyant sur le Neural Engine.

Qu'est-ce que FoundationModels ?

FoundationModels constitue le point d'entrée vers les modèles de langage d'Apple Intelligence dans vos applications. Ce n'est pas un service externe mais un framework intégré à iOS et macOS, accessible directement via Swift.

Il repose sur plusieurs piliers :

• L'exécution locale (rien ne sort de l'appareil)
• Une intégration native au système
• La possibilité de générer des données structurées grâce à des annotations Swift
• Un système extensible avec des Tools (fonctions personnalisées que le modèle peut invoquer)

Fonctionnement de base

Tout commence avec SystemLanguageModel, l'interface principale pour vérifier la disponibilité d'Apple Intelligence sur l'appareil et lancer une génération.

let model = SystemLanguageModel.default
 
switch model.availability {
case .available:
    Text("Apple Intelligence ready")
case .unavailable:
    Text("Model not available")
}

On crée ensuite une LanguageModelSession contenant les instructions et éventuellement des outils personnalisés. Le résultat est souvent récupéré sous forme de flux (streaming) pour afficher le contenu en temps réel.

Il est aussi possible de préchauffer le modèle avec prewarm(), ce qui élimine la latence du premier appel. Idéal si l'application exploite FoundationModels dès son ouverture.

let session = LanguageModelSession(instructions: Instructions {
  "Generate a short summary."
})
 
await session.prewarm()

Générer des données typées avec @Generable

L'une des innovations les plus marquantes est la génération directe de structures Swift typées. Avec l'annotation @Generable, on décrit la forme des données attendues et le modèle remplit les champs correspondants.

Pour créer un itinéraire de voyage, plutôt que de recevoir du texte libre, on peut demander une struct complète :

@Generable
struct Itinerary {
    @Guide(description: "Trip title")
    let title: String
    @Guide(.count(3))
    let days: [DayPlan]
}
 
@Generable
struct DayPlan {
    let title: String
    let activities: [String]
}

La génération passe par un ResponseStream<Type> dont chaque étape fournit un Snapshot. Ce snapshot contient une représentation partielle du type en cours de génération ainsi que des métadonnées comme la progression du streaming.

Guider la génération avec @Guide

L'annotation @Guide ajoute des contraintes ou des précisions. On peut imposer un format, limiter le nombre d'éléments ou restreindre les valeurs possibles.

@Guide(.format(.email))
let contactEmail: String
 
@Guide(.count(5))
let tags: [String]
 
@Guide(description: "List of tags describing the landmark")
let tags: [String]

Ces guides aident le modèle à rester cohérent et à produire des résultats conformes aux attentes, réduisant considérablement le post-traitement nécessaire.

Étendre le framework avec des Tools

Un Tool est une fonction Swift exposée au modèle, qu'il peut appeler lorsqu'il en a besoin. Cela permet de combiner intelligence générative et logique métier propre à l'application.

final class FindCafesTool: Tool {
    @Generable
    struct Arguments {
        let city: String
    }
 
    func call(arguments: Arguments) async throws -> String {
        return "Cafés populaires à \(arguments.city): Blue Bottle, Arabica, etc."
    }
}

Une fois défini, le tool est ajouté à une LanguageModelSession. Le modèle sait automatiquement qu'il peut l'utiliser.

Tutoriel SwiftUI : un planificateur de voyage

Mettons tout ensemble dans un projet SwiftUI. Un planificateur de voyage qui génère un itinéraire personnalisé et l'affiche progressivement à l'écran.

Le ViewModel pour gérer la session :

@Observable
@MainActor
final class TripPlanner {
    private let session: LanguageModelSession
    private(set) var snapshot: ResponseStream<Itinerary>.Snapshot?
 
    init() {
        self.session = LanguageModelSession(
            instructions: Instructions { "Generate a 3-day trip to Tokyo." }
        )
    }
 
    func generate() async {
        let stream = session.streamResponse(generating: Itinerary.self)
        for try await snapshot in stream {
            self.snapshot = snapshot
        }
    }
}

Et la vue SwiftUI :

struct TripView: View {
    @State private var planner = TripPlanner()
 
    var body: some View {
        VStack {
            if let itinerary = planner.snapshot?.content {
                Text(itinerary.title ?? "Loading...")
            }
        }
        .task { await planner.generate() }
    }
}

En une cinquantaine de lignes, on obtient une application qui génère un voyage en direct et l'affiche au fur et à mesure. Cela illustre la philosophie de FoundationModels : intégration fluide, réactivité et expérience utilisateur engageante.

Forces et limites

Points forts : rapidité, confidentialité (tout est local), aucune latence réseau, pas de coût cloud (pas de facturation au token, pas d'API externe).

Limites : disponible uniquement sur les appareils compatibles Apple Intelligence, principalement orienté texte (pas encore de multimodal avancé), pas de fine-tuning possible, choix de modèles limité.

Face à des solutions comme OpenAI, FoundationModels se distingue par sa sécurité et son intégration système, mais perd en flexibilité. Une approche typiquement Apple : fermée mais optimisée.

En conclusion

Avec FoundationModels, Apple ouvre un nouveau chapitre pour les développeurs. L'IA n'est plus un service distant consommé à travers le réseau mais une brique intégrée au système, conçue pour être rapide, privée et transparente. Ce n'est qu'un début, et la direction est claire : une intelligence artificielle locale qui enrichit nos applications sans compromettre la confidentialité.