Makros @Generable @Guide FoundationModels Swift

@Generable und @Guide Makros in FoundationModels: Automatisierte Modellgenerierung

Die @Generable- und @Guide-Makros im FoundationModels-Framework ermöglichen die Generierung von Swift-Strukturinstanzen basierend auf Sprachmodellausgaben. Der Compiler synthetisiert Protokolle und Methoden für Streaming-Antworten von LanguageModelSession. Dies reduziert Boilerplate-Code und gewährleistet Typsicherheit bei der Arbeit mit strukturierten Daten von LLMs.

Die Anwendung von @Generable auf eine Struktur macht sie mit Generierungsmechanismen kompatibel. Die Struktur muss Identifiable konform sein, um eine korrekte Objektidentifikation zu ermöglichen.

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

Der optionale description-Parameter klärt den Generierungskontext und leitet das LLM zu relevanten Ergebnissen.

@Generable(description: "Generiere Artikel für eine Einkaufsliste")
struct ShoppingItem: Identifiable {
    let id: String
    let value: String
}

Detaillierte Eigenschaften mit @Guide

Das @Guide-Makro wird auf einzelne Eigenschaften angewendet, um Anweisungen an das LLM zu geben. Dies bietet präzise Kontrolle über Feldinhalte, ohne die Modellgenerierungslogik zu verändern.

@Generable(description: "Generiere Artikel für eine Einkaufsliste")
struct ShoppingItem: Identifiable {
    let id: String

    @Guide(description: "Der Name des zu kaufenden Produkts")
    let value: String
}

@Guide-Annotationen werden als Direktiven an die Sprachmodellsitzung übergeben und beeinflussen das Parsing und die Validierung von Ausgaben. Dies ist nützlich für komplexe Strukturen mit verschachtelten Typen oder spezifischen Datenformaten.

Integration mit LanguageModelSession

Generierte Modelle werden über streamResponse in asynchrone Tasks integriert. Die Methode akzeptiert einen Ergebnistyp und einen Prompt und gibt einen Stream von Chunks zurück.

private func generateShoppingList() {
    let prompt = "Erstelle 15 Einkaufslistenartikel"
    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
        }
    }
}

Die Chunk-Verarbeitung umfasst das Filtern von nil-Werten und das Aktualisieren des UI-Zustands. Dies gewährleistet die Reaktionsfähigkeit der Benutzeroberfläche während der Generierung.

• Streaming-Verarbeitung: Chunks kommen asynchron an und minimieren Verzögerungen.
• Typsicherheit: Der Compiler überprüft die Protokollkonformität der Struktur.
• Validierung: Guard-Ausdrücke filtern unvollständige Objekte heraus.
• Fehlerbehandlung: Try-catch fängt Sitzungsfehler ab.

SwiftUI-Integration für gestreamte Generierung

In SwiftUI-Views werden Modelle an @State gebunden. Ein Button löst die Generierung aus und wird während der Ausführung deaktiviert.

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(
                    "Einkaufsliste generieren",
                    systemImage: "cart.fill.badge.plus"
                ) {
                    generateShoppingList()
                }
                .disabled(isGenerating)
            }
        }
    }

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

Die Benutzeroberfläche aktualisiert sich reaktiv, sobald Daten eintreffen. Dies demonstriert die praktische Anwendung für dynamische Inhalte in Apps.

Wichtige Erkenntnisse

• @Generable synthetisiert Protokolle für Streaming-Generierung von LLMs in Swift-Strukturen.
• @Guide bietet Eigenschafts-Level-Anweisungen für präzises Parsing von Ausgaben.
• Integration mit LanguageModelSession unterstützt asynchrones Streaming mit Typsicherheit.
• Geeignet für die Generierung von Listen, Formularen und dynamischen Daten in SwiftUI-Anwendungen.
• Reduziert Boilerplate-Code, während die Kontrolle über die generierte Objektstruktur erhalten bleibt.

— Editorial Team