Foundation Models w SwiftUI: lokalny AI

Lokalna sztuczna inteligencja w SwiftUI: integracja Foundation Models z przetwarzaniem strumieniowym

Framework Foundation Models od Apple umożliwia wdrażanie lokalnych modeli językowych w aplikacjach SwiftUI. Modele wykonują generowanie tekstu, podsumowywanie i klasyfikację całkowicie na urządzeniu, bez zapytań do chmury. Klasa LanguageModelSession zapewnia strumieniowe przesyłanie odpowiedzi przez metodę streamResponse(to:), co jest kluczowe dla responsywnych interfejsów.

Implementacja skupia się na przetwarzaniu zapytań użytkownika w czasie rzeczywistym: wprowadzanie tekstu, wysyłanie promptu i dynamiczne aktualizowanie wyjścia w miarę generowania fragmentów przez model.

Struktura interfejsu dla interakcji czatu

Aplikacja jest zbudowana wokół NavigationStack z ScrollView dla odpowiedzi AI i dolnym panelem wprowadzania. TextField z modyfikatorem glassEffect odpowiada iOS 26. Przycisk wysyłania aktywuje zadanie asynchroniczne, blokujące powtórne zapytania przez stan inputDisabled.

Pełny kod przykładu:

import SwiftUI
import FoundationModels

struct ContentView: View {
    @State private var input: String = ""
    @State private var output: String = ""
    @State private var inputDisabled: Bool = false

    var body: some View {
        NavigationStack {
            ScrollView {
                Text(output)
            }
        }
        .safeAreaBar(edge: .bottom) {
            inputAccessoryView
        }
    }

    private var inputAccessoryView: some View {
        HStack {
            TextField("Zapytaj mnie o cokolwiek", text: $input)
                .padding()
                .glassEffect()

            Button {
                sendPrompt()
            } label: {
                Image(systemName: "paperplane")
                    .frame(width: 25, height: 25)
                    .rotationEffect(.degrees(40))
            }
            .buttonStyle(.borderedProminent)
            .controlSize(.mini)
            .disabled(inputDisabled)
            .padding(8)
        }
    }

    private func sendPrompt() {
        Task {
            guard input.isEmpty == false else { return }

            do {
                let session = LanguageModelSession()
                inputDisabled = true

                let streamResponse = session.streamResponse(to: input)

                for try await chunk in streamResponse {
                    self.output = chunk
                }

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

Mechanizm strumieniowej generacji

Metoda streamResponse(to:) zwraca asynchroniczną sekwencję fragmentów tekstu. Pętla for try await chunk in streamResponse aktualizuje @State var output na każdym kroku, wyzwalając SwiftUI-ponowne renderowanie. Zapewnia to płynne UX bez blokujących operacji UI.

Obsługa błędów jest zaimplementowana przez do-catch: w przypadku awarii sesji wyświetlany jest localizedDescription, a pole wprowadzania jest odblokowywane.

Kluczowe aspekty integracji

• Przetwarzanie strumieniowe: Fragmenty są generowane przyrostowo, odpowiednie dla długich odpowiedzi; wymaga precyzyjnego zarządzania stanem, aby uniknąć warunków wyścigu.
• Poufność: Wszystkie obliczenia odbywają się na urządzeniu, dane nie opuszczają urządzenia.
• Wsparcie platformy: iOS 26+, macOS 26+, tvOS 26+, watchOS 26+.

Co jest ważne

• LanguageModelSession — główna klasa dla lokalnych sesji LLM z obsługą wsadową i strumieniową.
• streamResponse(to:) minimalizuje opóźnienia w UI dzięki przyrostowym aktualizacjom.
• Inferencja na urządzeniu eliminuje opóźnienia sieciowe i koszty API.
• SwiftUI @State + Task zapewniają współbieżność bez GCD.
• glassEffect — natywny modyfikator dla glassmorphism w iOS 26.

Optymalizacja wydajności

Dla programistów middle/senior: monitoruj ślad pamięci sesji — każda LanguageModelSession ładuje model do RAM. Zaleca się pulowanie sesji lub ponowne wykorzystanie instancji. Testuj na urządzeniach z Neural Engine (A17+ lub M3+). Przetwarzanie strumieniowe zmniejsza szczytowe obciążenie CPU, ale wydłuża czas w porównaniu z trybem wsadowym.

W produkcji dodaj debounce na wprowadzanie, historię kontekstu i fallback dla urządzeń o niskiej wydajności.

— Editorial Team