THIS IS ELLIE

Foundation Models로 AI 스토리 생성 앱 만들기

Ellie Kim — Sun, 11 Jan 2026 01:28:32 +0900

안녕하세요 :)

오늘도 어김없이 애플 Foundation Models를 활용해서 간단한 AI 스토리 생성 앱을 만들어보려고 합니다!
이번에 만들어볼 앱은 사용자가 설정한 입력값을 기반으로 감성적인 이야기를 자동 생성하고, 생성된 이야기를 음성으로 들려주는 스토리북 앱이고 네트워크 없이 온디바이스에서 동작해요

* 프로젝트를 시작하기 전에, Foundation Models을 사용하기 위한 몇가지 요구사항이 충족되어야 합니다!

@State 프로퍼티 정의

@State private var situation: String = "On an airplane"
@State private var likes: String = "bunnies, stars"
@State private var minutes: Int = 3

@State private var storyText: String = ""
@State private var isGenerating = false
@State private var errorText: String?

situation - 이야기의 상황
likes - 아이가 좋아하는 요소
minutes - 스토리 길이 (분)

storyText - 생성된 스토리 결과 텍스트
isGenerating - 생성 중 로딩 상태
errorText - 에러 메세지 표시용

body

var body: some View {
    NavigationStack {
        Form {
            Section("Story Settings") {
                TextField("Situation", text: $situation)
                TextField("Likes", text: $likes)
                
                Picker("Length", selection: $minutes) {
                    Text("1 min").tag(1)
                    Text("3 min").tag(3)
                    Text("5 min").tag(5)
                    Text("8 min").tag(8)
                    Text("12 min").tag(12)
                }
            }
            
            Section {
                Button {
                    Task { await generateAndSpeak() }
                } label: {
                    HStack {
                        Spacer()
                        if isGenerating { ProgressView() }
                        Text(isGenerating ? "Generating..." : "Generate & Play")
                        Spacer()
                    }
                }
                .disabled(isGenerating || !storyService.isAvailable)
                
                Button("Stop") {
                    speech.stop()
                }
            }
            
            if let errorText {
                Section("Error") { Text(errorText) }
            }
            
            Section("Story") {
                Text(storyText.isEmpty ? "No story yet." : storyText)
                    .textSelection(.enabled)
            }
        }
        .navigationTitle("StoryBook")
    }
}

body는 사용자가 이야기를 설정하고, AI가 생성한 스토리를 플레이 할 수 있는 전체 UI 흐름을 담당하고 있어요
코드는 크게 설정 입력, 버튼 액션, 결과/에러 표시의 구조로 나누어져있어요

generateAndSpeak()

@MainActor
private func generateAndSpeak() async {
    isGenerating = true
    errorText = nil
    storyText = ""
    
    do {
        let story = try await storyService.generateStory(
            situation: situation,
            minutes: minutes,
            likes: likes
        )
        storyText = story
        speech.speak(story)
    } catch {
        errorText = String(describing: error)
    }
    
    isGenerating = false
}

버튼을 탭하면 비동기 함수가 호출돼서 AI 스토리 생성 + TTS 재생이 차례로 실행되며
progressView()가 나타나며 현재 생성중인 상태를 표시해줘요
@MainActor를 사용해 UI 상태 업데이트를 메인 스레드에서 안전하게 업데이트해요

SpeechService

import AVFoundation
internal import Combine

@MainActor
final class SpeechService: NSObject, ObservableObject {
    private let synthesizer = AVSpeechSynthesizer()
    
    override init() {
        super.init()
        synthesizer.delegate = self
    }
    
    func speak(_ text: String) {
        stop()
        
        let utterance = AVSpeechUtterance(string: text)
        utterance.voice = AVSpeechSynthesisVoice(language: "en-US")
        utterance.rate = 0.45
        utterance.pitchMultiplier = 1.0
        utterance.preUtteranceDelay = 0.2
        utterance.postUtteranceDelay = 0.2
        
        synthesizer.speak(utterance)
    }
    
    func stop() {
        synthesizer.stopSpeaking(at: .immediate)
    }
}

extension SpeechService: AVSpeechSynthesizerDelegate {}

SpeechService는 AVSpeechSynthesizer를 이용해 텍스트를 음성으로 변환해줘요 (TTS)
아이를 위한 이야기이기 때문에 말하는 속도는 조금 느리게, 톤은 최대한 안정적으로 설정했어요

StoryService

import Foundation
import FoundationModels
internal import Combine

@MainActor
final class StoryService: ObservableObject {
    @Published var isAvailable: Bool = false
    @Published var statusMessage: String = ""
    
    private let session: LanguageModelSession
    
    init() {
        let model = SystemLanguageModel.default
        switch model.availability {
        case .available:
            isAvailable = true
            statusMessage = "모델 사용 가능"
        case .unavailable(let reason):
            isAvailable = false
            statusMessage = "모델 사용 불가: \(String(describing: reason))"
        }
        
        self.session = LanguageModelSession {
            """
            You write calming, safe bedtime-style stories for young children.
            Rules:
            - No scary, violent, or threatening content.
            - No medical or drug advice.
            - Use short, simple sentences.
            - Keep a warm, reassuring tone.
            - End with a gentle, calming closing.
            """
        }
    }
    
    func generateStory(
        situation: String,
        minutes: Int,
        likes: String
    ) async throws -> String {
        let target = targetWordCount(forMinutes: minutes)
        let prompt = """
        Situation: \(situation)
        Child likes: \(likes)
        Length: about \(target) words.
        
        Write the story in 4-6 short paragraphs.
        """
        
        let response = try await session.respond(to: prompt)
        return response.content
    }
    
    private func targetWordCount(forMinutes minutes: Int) -> String {
        switch minutes {
        case 1: return "120-180"
        case 3: return "350-500"
        case 5: return "650-900"
        case 8: return "1000-1300"
        case 12: return "1500-1900"
        default: return "350-500"
        }
    }
}

StoryService는 Foundation Models를 이용해 실제 스토리를 생성하는 핵심 로직을 담당해요
isAvailable을 통해 현재 디바이스에서 Foundation Models 사용 가능 여부를 판단하고
statusMessage를 통해 사용 가능/불가 상태를 UI에 전달하기 위한 메세지를 담아줍니다
시스템 프롬프트를 통해 Role을 명확히 지정해주고 사용자 입력 기반 프롬프트를 구성해줘요

결과는 요롷게 됩니다 ㅎㅎㅎ

전체 코드는 여기서 확인할 수 이써요!
https://github.com/kimhyeri/FoundationModelsPlayground/tree/main/CozyTales

FoundationModelsPlayground/CozyTales at main · kimhyeri/FoundationModelsPlayground

A collection of examples using Apple’s FoundationModels framework - kimhyeri/FoundationModelsPlayground

github.com

Foundation Models로 Workout Plan Generator만들기

Ellie Kim — Fri, 12 Dec 2025 14:43:09 +0900

안녕하세요 :)

오늘은 애플 Foundation Models을 활용해서 간단한 Workout Plan Generator를 만들어보려고 해요
이 간단한 앱의 기능은 사용자가 목표/운동 시간/장비/레벨을 선택하면, 온디바이스 모델이 맞춤형 운동 루틴을 생성해 주는 구조에요

*프로젝트 시작하기 전에, Foundation Models을 사용하기 위한 몇 가지 요구사항이 충족되어야 합니다!

@State 프로퍼티 정의

@State private var planText: String = "No workout plan yet.\nTap 'Generate Plan' to begin!"
@State private var isLoading: Bool = false
@State private var errorMessage: String?
@State private var goal: String = "Fat loss"
@State private var minutes: Int = 30
@State private var equipment: String = "Bodyweight"
@State private var level: String = "Beginner"

private let workoutAI = WorkoutAI()

planText는 안내 메세지를 담고 있고
isLoading은 로딩 상태 관리를 위한 변수이고
errorMessage는 에러 발생 시 UI에 표시할 텍스트를 담기 위한 변수이고
goal/minutes/equiment/level은 피커로 선택된 사용자 입력 값을 담기 위한 변수이고
workoutAI는 실질적으로 Foundtaion Models 호출을 담당하는 객체에요

body

var body: some View {
    NavigationStack {
        VStack(spacing: 20) {
            inputSection
            
            ScrollView {
                Text(planText)
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding()
                    .background(Color(.secondarySystemBackground))
                    .clipShape(RoundedRectangle(cornerRadius: 16))
            }
            
            if let errorMessage {
                Text(errorMessage)
                    .font(.footnote)
                    .foregroundStyle(.red)
            }
            
            Button {
                Task { await generatePlan() }
            } label: {
                if isLoading {
                    ProgressView()
                        .tint(.white)
                        .frame(maxWidth: .infinity)
                        .padding()
                } else {
                    Text("Generate Plan")
                        .frame(maxWidth: .infinity)
                        .padding()
                }
            }
            .font(.headline)
            .background(isLoading ? Color.gray : Color.blue)
            .foregroundStyle(.white)
            .clipShape(RoundedRectangle(cornerRadius: 16))
            .disabled(isLoading)
        }
        .padding()
        .navigationTitle("AI Workout")
        .navigationBarTitleDisplayMode(.inline)
    }
}

전체 화면은 다음과 같은 구조로 구성되어 있어요
1. Workout 옵션 입력 영역
2. 모델이 생성한 결과 영역
3. 에러 메세지
4. Generate Plan버튼

아래는 입력 영역이에요

private var inputSection: some View {
    VStack(alignment: .leading, spacing: 16) {
        Text("Workout Preferences")
            .font(.headline)
        
        VStack(alignment: .leading) {
            Text("Goal")
                .font(.caption)
                .foregroundStyle(.secondary)
            Picker("Goal", selection: $goal) {
                Text("Fat loss").tag("Fat loss")
                Text("Muscle gain").tag("Muscle gain")
                Text("Maintenance").tag("Maintenance")
            }
            .pickerStyle(.segmented)
        }
        
        VStack(alignment: .leading) {
            Text("Workout Duration (minutes)")
                .font(.caption)
                .foregroundStyle(.secondary)
            Picker("Minutes", selection: $minutes) {
                Text("10").tag(10)
                Text("20").tag(20)
                Text("30").tag(30)
                Text("45").tag(45)
                Text("60").tag(60)
            }
            .pickerStyle(.segmented)
        }
        
        VStack(alignment: .leading) {
            Text("Equipment")
                .font(.caption)
                .foregroundStyle(.secondary)
            Picker("Equipment", selection: $equipment) {
                Text("Bodyweight").tag("Bodyweight")
                Text("Dumbbells").tag("Dumbbells")
                Text("Gym equipment").tag("Gym equipment")
            }
            .pickerStyle(.segmented)
        }
        
        VStack(alignment: .leading) {
            Text("Experience Level")
                .font(.caption)
                .foregroundStyle(.secondary)
            Picker("Level", selection: $level) {
                Text("Beginner").tag("Beginner")
                Text("Intermediate").tag("Intermediate")
                Text("Advanced").tag("Advanced")
            }
            .pickerStyle(.segmented)
        }
    }
}

피커에는 목표, 운동시간, 장비, 난이도를 입력할 수 있도록 했어요

아래는 generatePlan함수

private func generatePlan() async {
    errorMessage = nil
    isLoading = true
    
    do {
        let text = try await workoutAI.generatePlan(
            goal: goal,
            minutes: minutes,
            equipment: equipment,
            level: level
        )
        await MainActor.run {
            self.planText = text
        }
    } catch {
        await MainActor.run {
            self.errorMessage = "Error generating plan: \(error.localizedDescription)"
        }
    }
    
    await MainActor.run {
        self.isLoading = false
    }
}

전반적인 흐름은 아래와 같아요
1. 에러메세지를 초기화
2. 로딩 시작
3. WorkoutAI.generatePlan()호출
4. LLM 응답을 planText에 반영
5. 에러 발생 시 메세지 출력
6. 로딩 종료

WorkoutAI

struct WorkoutAI {
    private let session: LanguageModelSession
    
    init() {
        let instructions = """
        You are a friendly and safe fitness coach.
        Generate short, safe home workout routines in English.
        Avoid medical advice. Keep it simple and beginner-friendly.
        Output should be plain text with bullet points.
        """
        
        self.session = LanguageModelSession(instructions: instructions)
    }
    
    func generatePlan(
        goal: String,
        minutes: Int,
        equipment: String,
        level: String
    ) async throws -> String {
        let prompt = """
        User information:
        - Goal: \(goal)
        - Workout duration: \(minutes) minutes
        - Experience level: \(level)
        - Available equipment: \(equipment)
        
        Please create a full-body workout routine in English that matches the information above.
        
        Format:
        - A short one-line summary at the top
        - Then bullet-point exercises (e.g., • Squats – 3 sets × 12 reps)
        - A short safety or caution note as the last line
        
        Keep it concise, around 8–12 lines in total.
        """
        
        let response = try await session.respond(to: prompt)
        return response.content
    }
}

먼저 LanguageModelSession을 생성해주고
instructions로 너는 운동 코치 역할이야!!!라는걸 알려주고
prompt로 사용자가 입력한 (goal/minuates/equipment/level)을 전달하고
마지막으로 모델이 생성한 content를 반환해줘요

여기서 중요한 점은!!
instruction은 모델의 역할을 정의해주고, prompt는 사용자 입력을 전달해 모델이 더 높은 품질의 결과를 생성할 수 있도록 해줘요

결과는 요렇게에 ㅎㅎ

전체 코드는 여기서 확인할 수 있어요!
https://github.com/kimhyeri/FoundationModelsPlayground/tree/main/WorkoutGuide

FoundationModelsPlayground/WorkoutGuide at main · kimhyeri/FoundationModelsPlayground

A collection of examples using Apple’s FoundationModels framework - kimhyeri/FoundationModelsPlayground

github.com

Foundation Models로 Recipe Generator 만들기

Ellie Kim — Fri, 8 Aug 2025 22:06:14 +0900

안녕하세요 :)

오늘은 애플 Foundation Models을 활용해서 streaming output 방식으로 간단한 Recipe Generator을 만들어볼게요

그전에 streaming output이 뭐냐??
non-streaming output(batch output)은 모델이 전체 응답을 다 생성한 후 한 번에 결과를 보내주는 방식이고
streaming output은 모델이 응답을 생성하면서 결과를 계속해서 보내주는 방식이에요

Apple의 Foundation Models에서는
streaming 방식을 활용할 수 있도록 PartiallyGenerated를 제공해줘요
Partially Generated - 이름만 봐도 알 수 있듯이 한번에 응답을 보내주는게 아니라
응답을 만들어 낼때마다 보내주기 때문에 UI를 부분적으로 업데이트할 수 있어요

그럼 바로 PartiallyGenerated를 활용해서 간단한 레시피 생성하는 앱을 만들어 볼게요

Recipe

@Generable(description: "A simple cooking recipe")
struct Recipe {
    let title: String
    @Guide(description: "List of required ingredients")
    let ingredients: [String]
    @Guide(description: "Summary of cooking instructions")
    let steps: String
}

먼저 Recipe 구조체를 생성해줍니다
@Generable, @Guide매크로를 활용해 모델이 해당 타입의 인스턴스를 자동으로 생성할 수 있게 했고
각각 description을 추가해 자연어로 설명을 추가해줘요
(for more detail: @Generable, @Guide)

ContentView

@State Properties

@State private var session = LanguageModelSession()
@State private var recipe: Recipe.PartiallyGenerated?
@State private var userInput: String = ""
@State private var isLoading: Bool = false

session - LanguageModelSession 인스턴스
recipe - 스트리밍으로 생성되는 레시피 결과 저장
userInput - 유저가 입력하는 텍스트 필드 값 보관
isLoading - 로딩 상태 표시를 위함

NavigationStack + VStack으로 구성된 body

var body: some View {
    NavigationStack {
        VStack(alignment: .leading, spacing: 16) {
            HStack {
                TextField("What would you like to cook?", text: $userInput)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    .disableAutocorrection(true)
                
                Button("Generate") {
                    UIApplication.shared.endEditing()
                    Task {
                        await generateRecipe()
                    }
                }
                .disabled(userInput.isEmpty)
            }
            
            ScrollView {
                if let recipe {
                    VStack(alignment: .leading) {
                        if let title = recipe.title {
                            Text(title)
                                .font(.title)
                                .bold()
                        }
                        
                        if let ingredients = recipe.ingredients {
                            Text("Ingredients:")
                                .font(.headline)
                            ForEach(ingredients, id: \.self) { item in
                                Text("- \(item)")
                            }
                        }
                        
                        if let steps = recipe.steps {
                            Text("Instructions:")
                                .font(.headline)
                            Text(steps)
                        }
                    }
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding()
                } else if isLoading {
                    VStack {
                        Spacer()
                        ProgressView("Generating recipe")
                            .padding()
                        Spacer()
                    }
                    .frame(maxWidth: .infinity, maxHeight: .infinity)
                }
            }
        }
        .padding()
        .navigationTitle("AI Recipe Generator")
    }
}

UI 관련 디테일은 생략하고, 간단한 흐름만 살펴보면
유저가 인풋 필드에 값을 입력한 후 Generate버튼을 누르면 키보드를 내려주고 generateRecipe()를 호출해 레시피 생성을 시작해줘요
generateRecipe()는 비동기 함수이기 때문에 await를 사용해 호출해 줍니다

generateRecipe()

func generateRecipe() async {
    isLoading = true
    recipe = nil
    do {
        let stream = session.streamResponse(generating: Recipe.self) {
            "Give me a recipe for \(userInput)"
        }
        for try await partial in stream {
            self.recipe = partial
        }
    } catch {
        print("Recipe generation error: \(error.localizedDescription)")
    }
    isLoading = false
}

generateRecipe()가 호출되면 isLoading을 true로 변경해 ProgressView를 보여줘요
그리고 세션에서 streamResponse(generating: Recipe.self)를 호출해 스트리밍 생성을 시작해요
유저 입력을 프롬프트로 전달하고 모델이 응답을 계속해서 보내줄 때 마다 self.recipe = partial로 업데이트를 해줍니다
self.recipe가 업데이트될 때마다 UI도 업데이트가 됩니당

아래는 전체 코드를 실행한 결과에요

그리고 전체 코드는 여기 올려뒀어요!
https://github.com/kimhyeri/FoundationModelsPlayground

GitHub - kimhyeri/FoundationModelsPlayground: A collection of examples using Apple’s FoundationModels framework

A collection of examples using Apple’s FoundationModels framework - kimhyeri/FoundationModelsPlayground

github.com

Apple Foundation Models - Tool calling

Ellie Kim — Thu, 7 Aug 2025 00:12:02 +0900

Tool Calling이란?
Foundation Models에 외부 도구를 알려주고, 모델이 이를 직접 호출할 수 있도록 해주는 기능이에요

왜 Tool calling이 필요한가?
일반적인 언어 모델은 학습된 시점의 지식에 한정되어 있어요
하지만 Tool calling을 활용하면 실시간 정보도 가져올 수 있고, 날씨, 지도, 캘린더 등 디바이스 기능을 활용할 수 있어요

protocol Tool
Tool은 프로토콜을 살펴보면 Sendable프로토콜을 준수하고 있어요
이유는 Foundation Models 프레임워크가 Tool을 concurrency 환경에서 실행하기 때문이에요

protocol Tool<Arguments, Output> : Sendable

따라서 Tool은 스레드-세이프하게 사용되도록 보장되어야 해요

애플 문서에 있는 예제를 조금 바꿔서 테스트해볼게요

FindContacts

struct FindContacts: Tool {
    let name = "findContacts"
    let description = "Find a specific number of contacts"

    @Generable
    struct Arguments {
        @Guide(description: "The number of contacts to get", .range(1...10))
        let count: Int
    }

    func call(arguments: Arguments) async throws -> ToolOutput {
        let contacts: [CNContact] = [
            mockContact(given: "Ellie", family: "Kim"),
            mockContact(given: "Ellie", family: "Lee"),
            mockContact(given: "Ellie", family: "Choi")
        ]
        let count = min(arguments.count, contacts.count)
        let names = contacts.prefix(count).map { "\($0.givenName) \($0.familyName)" }

        return ToolOutput(names.joined(separator: ", "))
    }

    private func mockContact(given: String, family: String) -> CNContact {
        let contact = CNMutableContact()
        contact.givenName = given
        contact.familyName = family
        return contact.copy() as! CNContact
    }
}

Tool프로토콜을 준수하는 구조체 FindContacts를 만들어줘요
Tool이 받을 입력 값인 Arguments를 정의해 줄게요

@Generable 매크로를 사용하면, 모델이 해당 타입의 인스턴스를 자동으로 생성할 수 있어요
또한, @Guide 매크로를 활용해 count에 대한 설명도 추가했어요
(@Generable, @Guide 잘 모르겠으면 참고)

call(arguments: Arguments) async throws -> ToolOutput는 Tool이 호출될 때 실행되는 비동기 함수예요
이 예제에서는 테스트 용으로 mockContact 3개 추가해 놨는데
실제 구현에서는 Contact 권한을 요청하고, 실제 디바이스의 연락처 정보를 불러오는 로직으로 대체하면 돼요

sendPrompt()
모델 세션을 생성할 때 사용할 Tool로 FindContacts를 같이 넣어줘요
이렇게 모델이 응답할 때 이 Tool을 쓸 수 있다는 걸 알려주는 거예요

func sendPrompt() async {
    let session = LanguageModelSession(tools: [FindContacts()])
    let prompt = "Can you give me 2 contacts?"
    
    do {
        let result = try await session.respond(to: prompt)
        print(result.content)
    } catch {
        return
    }
}

그리고 프롬프트를 전달하면, 모델은 FindContacts Tool을 활용해 아래와 같이 Ellie Kim, Ellie Lee를 생성해줘요

전체적인 Flow
1. FindContacts Tool을 사용할 수 있도록 모델 세션을 생성
2. Can you give me 2 contacts?라는 prompt 전달
3. 모델은 이 요청을 확인하고 Tool을 사용할지 말지 판단
4. 모델이 Tool호출이 필요하다고 판단되면 FindContacts.call 함수 실행
5. 반환된 결과를 바탕으로 응답 생성

resource:
https://developer.apple.com/documentation/foundationmodels/expanding-generation-with-tool-calling
https://developer.apple.com/documentation/foundationmodels/tool
https://developer.apple.com/videos/play/wwdc2025/259/

Apple FoundationModels - @Generable, @Guide

Ellie Kim — Tue, 5 Aug 2025 01:04:57 +0900

스위프트에서 @Generable 매크로를 구조체 structure나 열거형 enum에 적용하면,
Foundation Model이 프롬프트를 해석해 해당 타입의 인스턴스를 생성할 수 있어요
또한 @Guide 매크로를 통해 프로터피에 대한 자연어 설명을 추가할 수 있는데요,
이를 통해서 모델이 어떤 값을 생성해야 하는지 힌트를 얻고, 생성 결과를 컨트롤할 수 있어요

이전에 만들었던, Grammar Correction에 correctSentence()코드를 조금 수정해 볼게요

func correctSentence() async {
    isLoading = true
    correctionResult = ""
    errorMessage = nil

    UIApplication.shared.sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)

    do {
        let instructions = "You are a helpful and knowledgeable English tutor. When a student provides a sentence, check it for grammar mistakes. If there are any, explain what is wrong and provide the corrected sentence. If the sentence is already correct, confirm that it is correct and explain why."
        let session = LanguageModelSession(instructions: instructions)

        let prompt = """
        Please check the following sentence for any grammar mistakes. If there are mistakes, explain them and provide the corrected version. If the sentence is already correct, explain why it is correct.
        \"\(userInput.trimmingCharacters(in: .whitespacesAndNewlines))\"
        """
        
        let response = try await session.respond(to: prompt)
        correctionResult = response.content
    } catch {
        errorMessage = "Failed to get response: \(error.localizedDescription)"
    }

    isLoading = false
}

기존에는 crrectionResult에 response.content를 바로 넣어줬다면,
CorrectedSentence구조체를 생성한 후 해당 타입으로 반환받을 수 있게 바꿔볼게요

CorrectedSentence구조체에 @Generable매크로를 추가해 줍니다
(+ @Generable을 사용하려면 안에 있는 프로퍼티의 타입 또한 @Generable 이여야 해요)
@Guide매크로를 통해 모델이 어떤 값을 생성해야 할지 description을 작성해 줍니다

@Generable
struct CorrectedSentence {
    @Guide(description: "The grammatically correct version of the sentence.")
    var corrected: String
    @Guide(description: "Indicates whether the original sentence was grammatically correct.")
    var isCorrect: Bool
}

그리고 correctSentence함수안에 session.respond도 CorrectedSentence를 리턴할 수 있게 변경해 줍니다

func correctSentence() async {
     isLoading = true
     correctionResult = ""
     errorMessage = nil

     UIApplication.shared.sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)

     do {
         let instructions = "You are a helpful and knowledgeable English tutor. When a student provides a sentence, check it for grammar mistakes. If there are any, explain what is wrong and provide the corrected sentence. If the sentence is already correct, confirm that it is correct and explain why."
         let session = LanguageModelSession(instructions: instructions)

         let prompt = """
         Please check the following sentence for any grammar mistakes. If there are mistakes, explain them and provide the corrected version. If the sentence is already correct, explain why it is correct.
         \"\(userInput.trimmingCharacters(in: .whitespacesAndNewlines))\"
         """
         
         let response = try await session.respond(
             to: prompt,
             generating: CorrectedSentence.self
         )
         correctionResult = response.content.corrected
         print("isCorrect \(response.content.isCorrect)")
     } catch {
         errorMessage = "Failed to get response: \(error.localizedDescription)"
     }

     isLoading = false
 }

테스트해보니,
틀린 문장을 입력하면 corrected에 수정된 문장과 isCorrect가 false로 리턴되고
올바른 문장을 입력하면 corrected에 해당 문장과 isCorrect가 true가 리턴되네요

@Generable을 사용하면 모델의 출력을 직접 파싱하지 않아도 되기 때문에 훨씬 편리하네요!
결론 = 편하다, 좋다

resources:
https://developer.apple.com/videos/play/wwdc2025/259/
https://developer.apple.com/documentation/foundationmodels/generable https://developer.apple.com/documentation/foundationmodels/generating-swift-data-structures-with-guided-generation

애플 Foundation Models로 Grammar Correction 만들기

Ellie Kim — Sun, 27 Jul 2025 23:06:20 +0900

안녕하세요 :)

오늘은 애플 Foundation Models 프레임워크를 활용해서 간단한 Grammar Correction(문법 교정하는거?)을 만들어보려고 해요

시작하기 전에, Foundation Models를 사용하기 위한 몇 가지 요구사항이 충족되어야 하는데
이 글을 읽기 전에 내 환경에서 사용 가능한지 먼저 확인해 보시는 걸 추천드립니다!

@State 프로퍼티 정의

@State private var userInput: String = ""
@State private var correctionResult: String = ""
@State private var isLoading = false
@State private var errorMessage: String?

총 4개의 @State변수를 사용하고 있어요
userInput: 사용자가 입력한 문자를 담기 위한 변수
correctionResult: 응답 결과를 담을 문자열 변수
isLoading: 요청 중을 나타내는 플래그, progressView 제어
errorMessage: 에러 발생시 에러 메세지를 위한 변수

body

var body: some View {
    VStack(spacing: 16) {
        Text("  Enter a sentence you'd like to correct")
            .font(.headline)
            .frame(maxWidth: .infinity, alignment: .leading)
        
        TextEditor(text: $userInput)
            .frame(height: 120)
            .overlay(RoundedRectangle(cornerRadius: 8).stroke(Color.gray.opacity(0.4)))
            .padding(.horizontal, 4)
        
        HStack {
            Button(action: {
                userInput = ""
                correctionResult = ""
                errorMessage = nil
            }) {
                Label("Clear", systemImage: "xmark.circle")
            }
            .buttonStyle(.bordered)
            
            Spacer()
            
            Button(action: {
                Task {
                    await correctSentence()
                }
            }) {
                HStack {
                    if isLoading {
                        ProgressView()
                    } else {
                        Image(systemName: "wand.and.stars")
                        Text("Correct Grammar")
                    }
                }
            }
            .disabled(userInput.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || isLoading)
            .buttonStyle(.borderedProminent)
        }
        
        if let errorMessage = errorMessage {
            Text(errorMessage)
                .foregroundColor(.red)
        }
        
        if !correctionResult.isEmpty {
            VStack(alignment: .leading, spacing: 8) {
                Text("Correction & Explanation")
                    .font(.headline)
                ScrollView {
                    Text(correctionResult)
                        .frame(maxWidth: .infinity, alignment: .leading)
                }
                .frame(minHeight: 100)
            }
            .padding()
            .background(Color(.systemGray6))
            .cornerRadius(12)
        }
        
        Spacer()
    }
    .padding()
}

body는 크게
타이틀, 입력 필드, 버튼 영역, 결과 출력부분으로 구성되어 있어요
그냥 UI니까 여기는 패스

correctSentence()

func correctSentence() async {
    isLoading = true
    correctionResult = ""
    errorMessage = nil

    UIApplication.shared.sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)

    do {
        let instructions = "You are a helpful and knowledgeable English tutor. When a student provides a sentence, check it for grammar mistakes. If there are any, explain what is wrong and provide the corrected sentence. If the sentence is already correct, confirm that it is correct and explain why."
        let session = LanguageModelSession(instructions: instructions)

        let prompt = """
        Please check the following sentence for any grammar mistakes. If there are mistakes, explain them and provide the corrected version. If the sentence is already correct, explain why it is correct.
        \"\(userInput.trimmingCharacters(in: .whitespacesAndNewlines))\"
        """
        
        let response = try await session.respond(to: prompt)
        correctionResult = response.content
    } catch {
        errorMessage = "Failed to get response: \(error.localizedDescription)"
    }

    isLoading = false
}

Correct Grammar 버튼을 탭하면 비동기 함수인 correctSentence()가 호출되는데요
먼저, isLoading을 true로 설정하고 이전에 저장된 correctionResult와 errorMessage를 초기화시켜줍니다
그리고 키보드를 내려주기 위해서 resignFirstResponder()도 호출해 줍니다

이후, LanguageModelSession을 생성하고 instructions을 설정하는데요,
instruction은 대충
너는 친절하고 똑똑한 영어 튜터이고 문법 오류가 있는지 확인해 주고
오류가 있다면 왜 잘못되었는지와 올바른 문장을 제시해 주고,
문법 오류가 없다면 그 문장이 맞다는 것을 확인해 줘 뭐 이런 내용을 담았고
사용자 입력을 포함한 구체적인 prompt도 비슷하게 작성해 줬어요

작성한 prompt를 LLM에 전달하고 응답을 기다려요
응답이 오면, 그 내용을 correctionResult에 반영해 화면에 표시되게 해줘요
만약 에러가 발생하면 catch블록이 실행되어 errorMessage에 오류 내용을 저장하게 됩니다

여튼 결과를 표시하거나 오류 메세지를 출력한 후 로딩 상태를 false로 변경해 줍니다

+ 왜 instruction이랑 prompt랑 비슷한데 분리해놨냐?
instruction이랑 prompt가 비슷해 보이지만, 역할이 조금 달라요
instruction는 모델의 역할이나 동작 방식을 정의하는데 좀 더 포커스를 두고
prompt는 실제 유저의 질문 또는 입력을 반영해서 구체적인 요청을 전달해요

WWDC25 비디오에 보니까 둘을 분리하는 것이 더 좋은 아웃풋을 낸다고 하더라구요?

이 모든 코드를 조합하면 아래와 같이 간단한 Grammar Correction을 만들어 볼 수 있어요

전체 코드는 여기에 올려뒀어요!
https://github.com/kimhyeri/FoundationModelsPlayground

GitHub - kimhyeri/FoundationModelsPlayground: A collection of examples using Apple’s FoundationModels framework

A collection of examples using Apple’s FoundationModels framework - kimhyeri/FoundationModelsPlayground

github.com

애플 Foundation Models로 온디바이스 챗봇 만들기

Ellie Kim — Wed, 23 Jul 2025 23:48:00 +0900

안녕하세요 :)

애플에서 제공하는 온디바이스 LLM인 Foundation Models를 이용해서 간단한 챗봇을 만들어 볼게요

시작하기 전에 , Foundation Models를 사용하기 위한 몇 가지 요구사항이 있는데요
이 글을 읽기 전에 내 환경에서 사용 가능한지 먼저 확인해 보시는 걸 추천드립니다!

ChatView
먼저 뷰에서 사용할 세 가지 프로퍼티를 선언해줬어요

@StateObject private var viewModel = ChatViewModel()
@FocusState private var isInputFocused: Bool
@State private var lastMessageID: UUID?

viewModel은 채팅 메세지와 입력 상태 등을 관리하기 위한 뷰모델 인스턴스이고
isInputFocused는 텍스트 필드에 포커스가 되어 있는지 확인하기 위한 프로퍼티이고
lastMessageID는 마지막 메세지의 ID를 저장하는 변수예요

다음으로는 body

var body: some View {
    VStack {
        chatMessagesView
        Divider()
        inputView
    }
    .onTapGesture {
        isInputFocused = false
    }
}

chatMessageView는 채팅 메세지 목록을 보여주는 뷰고
Divider()을 추가해 메세지 목록이랑 입력창이랑 구분해 줬어요
inputView는 텍스트 필드와 전송 버튼이 있는 뷰예요
그리고 VStack에 onTapGesture등록해서 화면을 탭하면 키보드가 사라지도록 했어요

다음으로는 chatMessageView

private var chatMessagesView: some View {
    ScrollViewReader { proxy in
        ScrollView {
            LazyVStack(alignment: .leading, spacing: 12) {
                ForEach(viewModel.messages) { msg in
                    MessageBubble(message: msg)
                }
                if viewModel.isLoading {
                    ProgressView()
                        .frame(maxWidth: .infinity)
                }
            }
            .padding()
        }
        .onChange(of: viewModel.messages) { oldMessages, newMessages in
            if let lastID = newMessages.last?.id {
                lastMessageID = lastID
                withAnimation {
                    proxy.scrollTo(lastID, anchor: .bottom)
                }
            }
        }
    }
}

ScrollView + LazyVstack 조합으로 채팅 메세지를 세로로 나열해줘요
(LazyVStack을 사용하면 많은 메세지가 쌓여도 필요할 때만 뷰를 렌더링 해서 효율적이에요)
MessageBubble 각각의 메세지를 보여주는 뷰고
PregressView는 메세지 생성 중일 때 로딩 인디케이터를 표시하기 위한 뷰예요
onChange를 통해 새로운 메세지가 추가되면 마지막 메세지로 스크롤되도록 했어요

다음으로는 inputView

private var inputView: some View {
    HStack {
        TextField("Enter your message", text: $viewModel.currentInput)
            .textFieldStyle(RoundedBorderTextFieldStyle())
            .focused($isInputFocused)
            .submitLabel(.send)
            .onSubmit {
                sendMessage()
            }

        Button(action: sendMessage) {
            Text("Send")
        }
        .disabled(viewModel.isLoading || viewModel.currentInput.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
    }
    .padding()
    .background(Color(UIColor.systemBackground))
}

메세지를 입력할 수 있게 TextField를 생성했어요
텍스트 필드는 키보드 포커스를 감지하고 키보드에서 '보내기'를 보내는 경우 sendMessage()가 호출되도록 했어요
또한 Send 버튼을 추가해서 버튼이 눌렸을 때에도 sendMessage()가 불릴 수 있게 했어요
단, 입력이 비었거나 로딩중이면 버튼이 비활성화 돼요

다음으론 sendMessage()

private func sendMessage() {
    Task {
        isInputFocused = true
        await viewModel.send()
        if let lastID = viewModel.messages.last?.id {
            lastMessageID = lastID
        }
    }
}

현재 입력된 메세지를 전송을 하면 sendMessage()가 호출되어요
이 함수에서 viewModel.send()를 호출시켜 챗봇의 응답을 처리하도록 하고 마지막 메세지를 갱신해줘요

+ ChatView 전체 코드

import SwiftUI
import FoundationModels
import Combine

struct ChatView: View {
    @StateObject private var viewModel = ChatViewModel()
    @FocusState private var isInputFocused: Bool
    @State private var lastMessageID: UUID?

    var body: some View {
        VStack {
            chatMessagesView
            Divider()
            inputView
        }
        .onTapGesture {
            isInputFocused = false
        }
    }

    private var chatMessagesView: some View {
        ScrollViewReader { proxy in
            ScrollView {
                LazyVStack(alignment: .leading, spacing: 12) {
                    ForEach(viewModel.messages) { msg in
                        MessageBubble(message: msg)
                    }
                    if viewModel.isLoading {
                        ProgressView()
                            .frame(maxWidth: .infinity)
                    }
                }
                .padding()
            }
            .onChange(of: viewModel.messages) { oldMessages, newMessages in
                if let lastID = newMessages.last?.id {
                    lastMessageID = lastID
                    withAnimation {
                        proxy.scrollTo(lastID, anchor: .bottom)
                    }
                }
            }
        }
    }

    private var inputView: some View {
        HStack {
            TextField("Enter your message", text: $viewModel.currentInput)
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .focused($isInputFocused)
                .submitLabel(.send)
                .onSubmit {
                    sendMessage()
                }

            Button(action: sendMessage) {
                Text("Send")
            }
            .disabled(viewModel.isLoading || viewModel.currentInput.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
        }
        .padding()
        .background(Color(UIColor.systemBackground))
    }

    private func sendMessage() {
        Task {
            isInputFocused = true
            await viewModel.send()
            if let lastID = viewModel.messages.last?.id {
                lastMessageID = lastID
            }
        }
    }
}

MessageBubble

import SwiftUI

struct MessageBubble: View {
    let message: Message
    
    var body: some View {
        HStack {
            if message.role.isUser {
                Spacer()
            }

            Text(message.content)
                .padding(12)
                .background(message.role.bubbleColor)
                .cornerRadius(12)

            if message.role.isChatBot {
                Spacer()
            }
        }
    }
}

MessageBubble은 채팅 메세지를 위한 뷰예요
사용자 메세지와 챗봇 메세지를 구분해서 좌우 정렬하고 role에 따라 배경을 다르게 표시해 줍니다

Message

import Foundation

struct Message: Identifiable, Equatable {
    let id = UUID()
    let content: String
    let role: Role
    
    enum Role {
        case user, chatbot
    }
    
    static func == (lhs: Message, rhs: Message) -> Bool {
        return lhs.id == rhs.id && lhs.content == rhs.content && lhs.role == rhs.role
    }
}

id는 메세지를 구분할 수 있도록 UUID를 생성해서 넣어줬어요
content는 메세지 내용을 위한 것이고 role은 해당 메세지가 내 메세지인지 chatBot 메세지인지 구분하기 위한 enum프로퍼티예요

위 MessageBubble에서 사용자 메세지와 챗봇 메세지를 구분해서 각각 다른 색을 적용할건데 사용하기 쉽게 extension을 만들어줍니다

extension Message.Role {
    var bubbleColor: Color {
        switch self {
        case .user:
            return Color.blue.opacity(0.9)
        case .chatbot:
            return Color.gray.opacity(0.15)
        }
    }
    
    var isUser: Bool {
        return self == .user
    }
    
    var isChatBot: Bool {
        return self == .chatbot
    }
}

ViewModel

@Published var messages: [Message] = []
@Published var currentInput: String = ""
@Published var isLoading: Bool = false

private var session: LanguageModelSession?
private var conversationHistory: [String] = []
private let conversationHistoryLimit: Int = 10

messages 현재까지 주고받은 메세지를 담는 배열이고
currentInput은 입력창에 현재 입력된 텍스트를 담고
isLoading은 응답을 기다리는 중인지 여부를 확인하기 위한 프로퍼티예요
session 챗봇 대화를 처리하는 세션 객체이고
conversationHistory 과거 대화 내용을 문자열 배열로 저장하기 위한 프로퍼티이고
converstaionHistoryLimit은 대화 히스토리의 최대 저장 개수를 나타내는 프로퍼티예요

초기화

init() {
    let instructions = """
    You are a chatbot with a great sense of humor.  
    Engage the user with friendly and lighthearted conversation, occasionally adding humorous remarks.  
    Avoid excessive jokes and keep the conversation flowing naturally.
    Respond in a concise manner, typically with 1-3 sentences.
    """
    self.session = LanguageModelSession(instructions: instructions)
}

세션을 초기화할 때, 챗봇이 유머 감각을 갖고 동작하도록 instructions를 설정했어요
너무 길지 않게 1-3 문장의 답변을 리턴할 수 있게 설정했어요

다음으로는 send함수

func send() async {
    guard !currentInput.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return }
    
    let userMessage = currentInput
    currentInput = ""
    
    messages.append(Message(content: userMessage, role: .user))
    isLoading = true
    
    do {
        let response = try await sendToAI(text: userMessage)
        messages.append(Message(content: response, role: .chatbot))
    } catch {
        messages.append(Message(content: "Error: \(error.localizedDescription)", role: .chatbot))
    }
    
    isLoading = false
}

메세지를 입력하고 전송했을 때 실행되는 함수예요
공백은 무시되도록 했고 currentInput을 ""로 설정해 입력창을 초기화해줘요
그리고 사용자가 입력한 메세지를 messages배열에 추가해 화면에 표시되게 해줘요
로딩 상태를 활성화해주고 sendToAI()를 호출해줘요
sendToAI에서 받은 응답을 role = chatbot으로 설정해 주고 message에 추가해 줍니다
그리고 로깅 상태를 비활성화해 줍니다

sendToAI(text:)

private func sendToAI(text: String) async throws -> String {
    guard let session = session else {
        throw NSError()
    }
    
    conversationHistory.append("User: \(text)")
    
    let prompt = """
    Previous conversation:
    \(conversationHistory.joined(separator: "\n"))
    
    Chatbot: Let me respond to the user's latest message in a friendly and slightly humorous way.
    
    Response:
    """
    
    let response = try await session.respond(to: prompt)
    
    conversationHistory.append("Chatbot: \(response.content)")
    
    if conversationHistory.count > conversationHistoryLimit {
        conversationHistory = Array(conversationHistory.suffix(conversationHistoryLimit))
    }
    
    return response.content
}

conversationHistory에 유저의 입력값을 추가해 주고
최근 대화 히스토리를 포함한 프롬프트를 생성해줘요
이 프롬프트를 session.respond(to: prompt에 전달해 응답을 요청하고 챗봇의 응답을 conversationHistory에 추가해줘요
대화 히스토리 개수는 최대 10개까지 유지되도록 했고 응답받은 reponse.content는 리턴하도록 했어요

+ ChatViewModel 전체 코드

import Foundation
import FoundationModels
import Combine

@MainActor
class ChatViewModel: ObservableObject {
    @Published var messages: [Message] = []
    @Published var currentInput: String = ""
    @Published var isLoading: Bool = false
    
    private var session: LanguageModelSession?
    private var conversationHistory: [String] = []
    private let conversationHistoryLimit: Int = 10
    
    init() {
        let instructions = """
        You are a chatbot with a great sense of humor.  
        Engage the user with friendly and lighthearted conversation, occasionally adding humorous remarks.  
        Avoid excessive jokes and keep the conversation flowing naturally.
        Respond in a concise manner, typically with 1-3 sentences.
        """
        self.session = LanguageModelSession(instructions: instructions)
    }

    func send() async {
        guard !currentInput.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return }
        
        let userMessage = currentInput
        currentInput = ""
        
        messages.append(Message(content: userMessage, role: .user))
        isLoading = true
        
        do {
            let response = try await sendToAI(text: userMessage)
            messages.append(Message(content: response, role: .chatbot))
        } catch {
            messages.append(Message(content: "Error: \(error.localizedDescription)", role: .chatbot))
        }
        
        isLoading = false
    }

    private func sendToAI(text: String) async throws -> String {
        guard let session = session else {
            throw NSError()
        }
        
        conversationHistory.append("User: \(text)")
        
        let prompt = """
        Previous conversation:
        \(conversationHistory.joined(separator: "\n"))
        
        Chatbot: Let me respond to the user's latest message in a friendly and slightly humorous way.
        
        Response:
        """
        
        let response = try await session.respond(to: prompt)
        
        conversationHistory.append("Chatbot: \(response.content)")
        
        if conversationHistory.count > conversationHistoryLimit {
            conversationHistory = Array(conversationHistory.suffix(conversationHistoryLimit))
        }
        
        return response.content
    }
}

여기까지!
이 모든 코드를 조합하면 아래와 같이 간단한 챗봇을 만들어 볼 수 있어요
instructions, prompt를 다르게 변경해서 원하는 종류의 챗봇을 직접 만들어봐도 좋을 것 같아요

전체 코드는 여기에 올려뒀어요
https://github.com/kimhyeri/FoundationModelsPlayground

GitHub - kimhyeri/FoundationModelsPlayground: A collection of examples using Apple’s FoundationModels framework

A collection of examples using Apple’s FoundationModels framework - kimhyeri/FoundationModelsPlayground

github.com

Foundation Models - Design for on-device LLM (2)

Ellie Kim — Mon, 21 Jul 2025 22:50:25 +0900

프롬프트 작성 모범 사례

모델이 생성하는 콘텐츠의 양은 프롬프트로 직접 조절할 수 있어요
(예: In a single paragraph, In three sentences 등)

프롬프트에 역할을 명시함으로써 스타일과 어투를 조절할 수 있어요
이와 같이 모델은 프롬프트에 따라 다양한 역할을 수행할 수 있어요

Prompting best practices

프롬프트는 명확한 명령어처럼 작성하세요
모델은 하나의 구체적인 작업을 수행할 때 가장 잘 동작해요
또, 원하는 출력 예시를 4개 미만으로 직접 프롬프트 안에 작성하면 효과를 높일 수 있어요
해야 할 일을 강조할 때는 대문자로 MUST, 하지 말아야 할 일을 강조할 때는 대문자로 DO NOT 이런 식으로 단호한 어조로 사용해 보세요

Xcode #Playground 활용하기

프롬프트 실험을 해보고 싶다면 Xcode에서 지원하는 Playground메크로를 활용해 보세요
스유 프리뷰처럼 오른쪽 캔버스에 즉시 응답을 확인할 수 있어요

prompt와 instructions의 차이

Instructions은 FoundationModels프레임워크에서 제공하는 또 다른 프롬프트 형식인데,
모델이 지속적으로 어떤 방식으로 응답할지 지정하는 역할을 해요
Instructions을 추가하면, 모델은 먼저 이 지시를 인지한 후에 프롬프트를 받아요 (우선 적용)

AI safety
프롬프트는 사용자로부터 받을 수 있는데 예상치 못한 입력이나 악의적인 입력이 들어올 수 있어서 이를 대비해 안전을 고려해야 해요
프레임워크에는 Apple이 사전 학습시킨 가드레일이 내장되어 있고 이는 입력 출력 모두에 적용되어요

프롬프트, instructions 같은 입력이 안전한지 감지해 차단하고

모델이 부적절한 출력을 하려 해도 가드레일이 이를 차단해요

코드로 위와 같은 에러를 감지할 수 있어요
사용자 입력으로 인한 기능이면 적절한 피드백을 보여주고, 앱이 알아서 수행하는 기능이라면 무시할 수도 있어요

Evaluate and test
앱에서 생성되는 콘텐츠와 품질과 안전성을 보장하려면 테스트가 필수예요
주요 사용 사례를 다룰 수 있는 프롬프트와 문제를 유발하는 프롬프트 모두를 수집해서 데이터셋을 구성해서 테스트하세요
소규모는 수동 점검, 대규모는 자동화 툴 + LLM 기반 평가 도입 기능이 필요하며 비정상 시나리오도 테스트가 필요해요

체크리스트
1. 가드레일 에러 발생 시 핸들링하는 UI를 만들 것
2. Instructions에 안전 지침 포함할 것
3. 사용자 입력을 안전하게 조합한 프롬프트를 설계할 것
4. 생성된 콘텐츠가 사용자에게 미치는 영향 고려할 것
5. 테스트 및 평가 자동화 도구 구축할 것
6. 문제 발견 시 Apple에 리포트할 것

resource: https://developer.apple.com/videos/play/wwdc2025/248/

Foundation Models - Design for on-device LLM (1)

Ellie Kim — Mon, 21 Jul 2025 00:58:20 +0900

prompt 프롬프트란?

생성형 AI 모델에 입력하는 텍스트를 의미해요
이 텍스트는 모델의 응답을 유도하는 역할을 하며, 자연어로 즉 동료에게 메시지 보내듯 작성하면 돼요

프롬프트 예시: Generate a bedtime story about a fox
(예시에선 영어로 작성했지만, Apple Intelligence가 지원하는 언어 암거나 가능해요)

https://www.apple.com/kr/newsroom/2025/02/apple-intelligence-expands-to-more-languages-and-regions-in-april/

한국어도 공식적으로 지원하므로, 한국어도 사용할 수 있어요
여튼, 이 프롬프트를 Language Model Session에 입력하면 모델은 이에 관련된 동화를 만들어내요

온디바이스 LLM 작동 방식
애플의 Foundation Models프레임워크에서는, 프롬프트가 온디바이스 LLM로 전달되어요

LLM은 텍스트를 이해하고 생성할 수 있는 모델이고
이는 general purpose 모델로 iOS, iPadOS, macOS, visionOS 같은 운영체제에 내장되어 있어요

온디바이스 LLM을 위한 디자인 전략

이 모델은 사용자의 기기 내에서 작동하며, 아래와 같은 언어 작업에 사용할 수 있어요
(요약, 분류, 멀티 턴 대화, 텍스트 작성, 텍스트 수정, 텍스트에서 태그 추출하기)
하지만 이 모델은 모바일 기기에 적합하도록 최적화 및 압축된 버전이에요

모델 사이즈

애플이 사용하는 모델은 약 3B크기로 여전히 강력한 머신러닝 모델이긴 하지만,
서버 베이스 LLM과 비교해서는 매우 작아요
이런 서버 LLM들은 수백억 - 수천억 개의 파라미터를 가지고 있어요

크기에 따른 제약사항

크기 차이 때문에, 서버 기반 LLM에서 잘 작동하던 작업이 온디바이스 모델에서는 작동하지 않을 수도 있어요
복잡한 추론이 필요한 작업에서 결과가 만족스럽지 않다면, 프롬프트를 더 단순한 단계들로 나누는 것을 시도해 보세요
수학 관련 작업의 경우, 계산기를 대신하도록 모델에 맡기는 것은 피하세요
수학은 AI가 아닌 일반 코드로 처리하는 것이 훨씬 안정적이에요
또한, 이 시스템은 코드 생성에 최적화되어 있지 않기 때문에, 코드 작성 작업도 피하는 것이 좋아요

모델 크기 때문에 world events에 대한 지식도 제한적이에요
예를 들어, 모델이 학습한 이후에 발생한 최근 사건에 대해서는 알지 못해요

Hallucination 환각

Hallucination이 뭐냐?
모델이 모르는 정보를 요청받았을 때, 완전히 사실이 아닌 내용을 지어낼 수 있는데 이것을 Hallucination이라고 불러요
이 때문에 사람들에게 잘못된 정보를 줄 수 있어요
따라서 시스템 언어 모델을 사실에 의존하는 용도로 사용하지 마세요
만약 정확한 사실을 생성하고 싶다면, 검증된 정보를 프롬프트에 직접 포함시켜 주고
새로운 프롬프트를 작성할 때마다, 모델이 출력한 결과를 반드시 검증하세요

resource: https://developer.apple.com/videos/play/wwdc2025/248/

Apple Foundation Models 사용해보기

Ellie Kim — Fri, 18 Jul 2025 02:55:57 +0900

안녕하세요 :)

애플이 Xcode 26부터 지원해 주는 playground 매크로덕에,
FoundationModels 프레임워크를 테스트하기가 너무 편하더라구요
await, try, throws 등과 같은 비동기/동기 코드도 지원하고
전체 앱 빌드 없이도 코드 스니펫만 빠르게 실행할 수 있어서요
이 playground 매크로를 활용해서 FoundationModels을 테스트해보려고 해요

FoundationModels프레임워크를 사용해 온디바이스 LLM을 실행하고,
프롬프트에 대한 응답을 생성하는 아주 간단한 예제를 실행해봤어요

LanguageModelSession은 애플의 FoundationModels프레임워크에서 사용하는 객체로,
온디바이스에서 LLM을 실행하고 세션 단위로 제어할 수 있게 해주는 클래스예요

프롬프트인 List the top 5 fastest-growing stock markets in 2025를 모델에 전달해 볼게요
모델이 해당 요청에 대해 텍스트 응답을 생성하고 그 결과를 출력하도록 했어요

와 근데 11.4s 실화?
온디바이스 LLM인데?
실시간 인터랙션용으로는 아직은 조금 느릴 수도 있겠다 싶어요

그리고 2025년 기준으로 가장 빠르게 성장 중인 주식시장 5곳을 알려줘라고 했는데
실제 주식거래소나 증시 시장 이름이 아닌 국가를 알려주고 있네요 ㅎㅎ;
모델 응답 내용이 조금 아쉽긴 하지만 이런 점도 점차 개선될 거라 기대해야죠

그래도 애플은 앱 업데이트 없이도 OS나 프레임워크 레벨에서 모델을 갱신할 수 있는 구조를 제공하고 있어서
유저는 항상 최신의 모델을 쓸 수 있어 이 부분은 사용자 입장에서 큰 장점이라고 생각 들어요

아직 베타라 그런지 속도와 모델 응답 부분에서 아쉬움이 남지만,
그래도 점차 나아지겠죠 (기대 중)

결론 : 애플 더 힘내줘