Macros @Generable @Guide FoundationModels Swift

Les macros @Generable et @Guide dans FoundationModels : Automatiser la génération de modèles

Les macros @Generable et @Guide du framework FoundationModels permettent de générer des instances de structures Swift à partir des sorties d'un modèle de langage. Le compilateur synthétise les protocoles et méthodes nécessaires pour diffuser les réponses d'une LanguageModelSession. Cela réduit le code répétitif et garantit la sécurité des types lors du travail avec des données structurées provenant de LLM.

L'application de @Generable à une structure la rend compatible avec les mécanismes de génération. La structure doit se conformer à Identifiable pour une identification correcte des objets.

@Generable
struct ShoppingItem: Identifiable {
    let id: String
    let value: String
}

Le paramètre optionnel description clarifie le contexte de génération, guidant le LLM vers des résultats pertinents.

@Generable(description: "Générer des articles pour une liste de courses")
struct ShoppingItem: Identifiable {
    let id: String
    let value: String
}

Détail des propriétés avec @Guide

La macro @Guide s'applique à des propriétés individuelles pour fournir des instructions au LLM. Cela offre un contrôle précis sur le contenu des champs sans altérer la logique de génération du modèle.

@Generable(description: "Générer des articles pour une liste de courses")
struct ShoppingItem: Identifiable {
    let id: String

    @Guide(description: "Le nom du produit à acheter")
    let value: String
}

Les annotations @Guide sont transmises à la session du modèle de langage comme des directives, influençant l'analyse et la validation des sorties. C'est utile pour les structures complexes avec des types imbriqués ou des formats de données spécifiques.

Intégration avec LanguageModelSession

Les modèles générés s'intègrent dans des tâches asynchrones via streamResponse. La méthode accepte un type de résultat et un prompt, et renvoie un flux de fragments.

private func generateShoppingList() {
    let prompt = "Créer 15 articles pour une liste de courses"
    Task {
        do {
            let session = LanguageModelSession()

            let response = session.streamResponse(
                generating: [ShoppingItem].self
            ) {
                prompt
            }

            isGenerating = true

            for try await chunk in response {
                self.shoppingList = chunk.compactMap {
                    guard let id = $0.id, let task = $0.value else {
                        return nil
                    }

                    return ShoppingItem(id: id, value: task)
                }
            }

            isGenerating = false
        } catch {
            print(error.localizedDescription)
            isGenerating = false
        }
    }
}

Le traitement des fragments inclut le filtrage des valeurs nulles et la mise à jour de l'état de l'interface utilisateur. Cela garantit la réactivité de l'interface pendant la génération.

• Traitement en flux continu : Les fragments arrivent de manière asynchrone, minimisant les délais.
• Sécurité des types : Le compilateur vérifie la conformité de la structure aux protocoles.
• Validation : Les expressions guard filtrent les objets incomplets.
• Gestion des erreurs : Le bloc try-catch capture les échecs de session.

Intégration SwiftUI pour la génération en flux

Dans les vues SwiftUI, les modèles sont liés à @State. Un bouton déclenche la génération et devient désactivé pendant l'exécution.

struct ContentView: View {
    @State private var shoppingList: [ShoppingItem] = []
    @State private var isGenerating: Bool = false

    var body: some View {
        List(shoppingList) { item in
            Text(item.value)
        }
        .toolbar {
            ToolbarItem(placement: .bottomBar) {
                Button(
                    "Générer la liste de courses",
                    systemImage: "cart.fill.badge.plus"
                ) {
                    generateShoppingList()
                }
                .disabled(isGenerating)
            }
        }
    }

    private func generateShoppingList() {
        // ...
    }
}

L'interface utilisateur se met à jour de manière réactive à l'arrivée des données. Cela démontre une application concrète pour du contenu dynamique dans les applications.

Points clés à retenir

• @Generable synthétise les protocoles pour la génération en flux des LLM vers des structures Swift.
• @Guide fournit des instructions au niveau des propriétés pour une analyse précise des sorties.
• L'intégration avec LanguageModelSession prend en charge la diffusion asynchrone avec sécurité des types.
• Adapté pour générer des listes, des formulaires et des données dynamiques dans les applications SwiftUI.
• Réduit le code répétitif tout en conservant le contrôle sur la structure des objets générés.

— Editorial Team