إطار Foundation Models في iOS 26: دليلك لبناء تطبيقات ذكاء اصطناعي على الجهاز

مقدمة: عصر جديد من الذكاء الاصطناعي المدمج في iOS

تخيّل معي: تطبيق iOS يفهم اللغة الطبيعية، يُولّد محتوى ذكي، ويُصنّف النصوص — كل هذا بدون إنترنت، بدون مفاتيح API، وبدون أي تكلفة. يبدو كأنه حلم، صح؟

الخبر الجيد إن هذا الحلم صار واقع.

مع iOS 26، أطلقت Apple إطار Foundation Models اللي يمنحك وصول مباشر إلى نفس النموذج اللغوي الكبير (LLM) اللي يشغّل Apple Intelligence — نموذج بحجم 3 مليار معامل (parameter) يعمل بالكامل على الجهاز. لا سحابة، لا اشتراكات، لا قلق على خصوصية المستخدمين. صراحةً، لمّا جرّبته لأول مرة انبهرت بسرعة الاستجابة.

في هذا الدليل، راح نستكشف إطار Foundation Models من الصفر حتى الأنماط المتقدمة: من توليد النصوص البسيط، إلى التوليد الموجّه (Guided Generation) الآمن نوعيًا، إلى البث المباشر (Streaming) في واجهات SwiftUI، وصولًا إلى استدعاء الأدوات (Tool Calling). هيا نبدأ!

ما هو إطار Foundation Models؟

إطار Foundation Models هو واجهة برمجية (API) من Apple تمنح المطوّرين وصولًا مباشرًا إلى النموذج اللغوي المدمج في الجهاز — نفس النموذج اللي يُشغّل ميزات Apple Intelligence مثل تلخيص الإشعارات وتحسين النصوص.

الخصائص الأساسية للإطار

• يعمل على الجهاز بالكامل: لا يحتاج اتصال إنترنت — كل المعالجة تتم محليًا على شريحة Apple Silicon.
• مجاني تمامًا: لا رسوم استخدام ولا حدود للطلبات. استخدمه بلا قيود.
• خصوصية مطلقة: بيانات المستخدمين ما تغادر الجهاز أبدًا — وهذي ميزة تنافسية ضخمة مع تزايد اهتمام الناس بالخصوصية.
• زمن استجابة منخفض: بدون رحلات ذهاب وإياب للسحابة، الاستجابة تكون شبه فورية.
• تكامل أصيل مع Swift: واجهة برمجية مبنية بالكامل بلغة Swift مع دعم كامل لنظام الأنواع والماكرو.

ماذا يمكنك بناؤه؟

الاستخدامات واسعة جدًا: اقتراحات بحث ذكية داخل تطبيقك، توليد محتوى نصي (مقالات، ملخصات، أوصاف منتجات)، تصنيف المحتوى تلقائيًا، بناء مساعد ذكي داخل التطبيق، توليد حوارات لشخصيات الألعاب، أو حتى إنشاء اختبارات ومسابقات. القائمة تطول بصراحة.

المتطلبات التقنية

لاستخدام إطار Foundation Models، تحتاج:

• Xcode 26 أو أحدث
• جهاز Mac بشريحة Apple Silicon يعمل بنظام macOS Tahoe 26
• للاختبار على جهاز حقيقي: iPhone أو iPad متوافق مع Apple Intelligence يعمل بنظام iOS 26

ملاحظة مهمة: الإطار لا يعمل في محاكي iOS (Simulator) — تحتاج جهاز حقيقي للاختبار. هذي نقطة أزعجتني شخصيًا في البداية، لكن منطقية لأن النموذج يحتاج شريحة Apple Silicon الفعلية.

البداية: توليد النصوص الأساسي

نبدأ بأبسط شكل ممكن — توليد نص من النموذج اللغوي. والأمر بسيط بشكل مذهل.

إنشاء جلسة والحصول على استجابة

التفاعل مع النموذج يبدأ بإنشاء LanguageModelSession. هذه الجلسة تحافظ على سياق المحادثة بين الطلبات:

import FoundationModels

// إنشاء جلسة بسيطة
let session = LanguageModelSession()

// إرسال طلب والحصول على استجابة
let response = try await session.respond(to: "اشرح مفهوم البرمجة الكائنية في جملتين")
print(response.content)

سطران فقط من الكود الفعلي! تستورد الإطار، تُنشئ جلسة، وتطلب من النموذج. لا مفاتيح API، لا إعدادات معقدة. بس كذا.

إضافة تعليمات النظام (System Instructions)

لتوجيه سلوك النموذج، تقدر تمرّر تعليمات عند إنشاء الجلسة:

let session = LanguageModelSession(
    instructions: "أنت مساعد برمجي متخصص في Swift. أجب دائمًا باللغة العربية مع أمثلة كود عملية."
)

let response = try await session.respond(
    to: "كيف أستخدم guard let في Swift؟"
)
print(response.content)

التعليمات تُشكّل شخصية النموذج وتُحدّد أسلوب إجاباته. وهذا مفيد جدًا لمّا تبي النموذج يتصرّف بطريقة معينة — مثلًا كمعلّم صبور، أو كخبير تقني يعطيك الزبدة مباشرة.

استخدام Foundation Models في واجهة SwiftUI

في تطبيق SwiftUI حقيقي، تُخزّن الجلسة كـ @State وتتعامل معها عبر دوال غير متزامنة:

import SwiftUI
import FoundationModels

struct AIAssistantView: View {
    @State private var session = LanguageModelSession()
    @State private var userInput = ""
    @State private var aiResponse = ""
    @State private var isLoading = false

    var body: some View {
        VStack(spacing: 16) {
            ScrollView {
                Text(aiResponse)
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding()
            }

            HStack {
                TextField("اكتب سؤالك...", text: $userInput)
                    .textFieldStyle(.roundedBorder)

                Button("إرسال") {
                    Task { await sendMessage() }
                }
                .disabled(isLoading || userInput.isEmpty)
            }
            .padding()
        }
    }

    private func sendMessage() async {
        isLoading = true
        defer { isLoading = false }

        do {
            let response = try await session.respond(to: userInput)
            aiResponse = response.content
            userInput = ""
        } catch {
            aiResponse = "حدث خطأ: \(error.localizedDescription)"
        }
    }
}

الجميل هنا إن الجلسة تحتفظ بسياق المحادثة. يعني لو سألت النموذج سؤال ثم سألته سؤال متابع، بيفهم السياق السابق — تمامًا كمحادثة طبيعية مع شخص حقيقي.

التوليد الموجّه: @Generable و @Guide

صراحةً، هذي هي أقوى ميزة في الإطار — والسبب الرئيسي اللي يخليني متحمس له.

المشكلة المعتادة مع النماذج اللغوية إنها تُرجع نصوص حرة (free-form text). لو طلبت من ChatGPT قائمة مهام بتنسيق JSON، ممكن يرجع JSON صحيح... وممكن لا. وتضطر تحاول تحلل النص وتعالج الأخطاء — وهذا صداع ما بعده صداع.

إطار Foundation Models يحل هذي المشكلة من جذورها عبر التوليد الموجّه (Guided Generation). بدل ما تحصل على نص حر وتحاول تحلله، تحصل مباشرة على كائنات Swift مُهيكلة وآمنة نوعيًا (type-safe).

ماكرو @Generable: تحويل الهياكل إلى مخرجات ذكية

ماكرو @Generable يُخبر الإطار إن هذا النوع يمكن للنموذج اللغوي يولّد نسخ منه:

import FoundationModels

@Generable
struct BookRecommendation {
    let title: String
    let author: String
    let summary: String
    let rating: Int
}

// الاستخدام
let session = LanguageModelSession()
let response = try await session.respond(
    to: "رشّح لي كتابًا عن البرمجة للمبتدئين",
    generating: BookRecommendation.self
)

let book = response.content
print(book.title)    // عنوان الكتاب
print(book.author)   // اسم المؤلف
print(book.summary)  // ملخص الكتاب
print(book.rating)   // تقييم رقمي

الشيء المذهل: النموذج مُجبر على إنتاج مخرجات تتطابق مع هيكل Swift اللي حدّدته. ما يقدر يرجع JSON غير صالح أو حقول ناقصة. هذا يتم عبر تقنية اسمها الفك المقيّد (Constrained Decoding) حيث يُقيّد النموذج على مستوى الرموز (tokens) فما يُنتج إلا مخرجات صالحة.

ماكرو @Guide: التحكم الدقيق في كل خاصية

ماكرو @Guide يمنحك تحكم أدق في القيم اللي يُنتجها النموذج لكل خاصية:

@Generable
struct RecipeIdea {
    @Guide(description: "اسم الوصفة بالعربية")
    let name: String

    @Guide(description: "المدة التقريبية للتحضير بالدقائق")
    let prepTimeMinutes: Int

    @Guide(.anyOf(["سهل", "متوسط", "صعب"]))
    let difficulty: String

    @Guide(description: "قائمة المكونات الرئيسية", .count(5...8))
    let ingredients: [String]

    @Guide(description: "خطوات التحضير بالترتيب")
    let steps: [String]
}

لاحظ القوة هنا:

• description يعطي النموذج تلميح بلغة طبيعية عن المطلوب.
• .anyOf يُقيّد القيمة لتكون واحدة من خيارات محددة — مستحيل النموذج يرجع قيمة خارج القائمة.
• .count(5...8) يُحدّد عدد عناصر المصفوفة — هنا بين 5 و 8 مكونات.

مثال عملي: مولّد خطط رحلات

خلّنا نبني شي أكثر واقعية — مولّد خطط رحلات ذكي:

@Generable
struct DayPlan {
    @Guide(description: "عنوان جذاب لبرنامج اليوم")
    let title: String

    @Guide(description: "الأنشطة المقترحة لهذا اليوم بالترتيب", .count(3...5))
    let activities: [String]

    @Guide(description: "نصيحة عملية للمسافر عن هذا اليوم")
    let tip: String
}

@Generable
struct TravelItinerary {
    @Guide(description: "اسم مشوّق للرحلة")
    let tripName: String

    @Guide(description: "وصف موجز وجذاب للرحلة")
    let description: String

    @Guide(description: "برنامج كل يوم من أيام الرحلة")
    let days: [DayPlan]
}

// الاستخدام
let session = LanguageModelSession(
    instructions: "أنت خبير سياحة متخصص في تخطيط الرحلات. أنشئ خطط رحلات مفصلة وعملية."
)

let itinerary = try await session.respond(
    to: "خطط لي رحلة 3 أيام إلى إسطنبول",
    generating: TravelItinerary.self
).content

print(itinerary.tripName)
for day in itinerary.days {
    print("📅 \(day.title)")
    for activity in day.activities {
        print("  • \(activity)")
    }
    print("💡 \(day.tip)")
}

النتيجة: كائن Swift مُهيكل بالكامل تقدر تعرضه مباشرة في واجهة SwiftUI بدون أي تحليل يدوي. وهذا — من تجربتي — يوفّر ساعات من كتابة كود التحليل ومعالجة الأخطاء.

نقطة مهمة: ترتيب الخصائص يهم!

النموذج يُولّد قيم الخصائص بالترتيب المُعلن في الكود. فإذا كانت خاصية تعتمد على قيمة خاصية أخرى، لازم تحطها بعدها:

@Generable
struct QuizQuestion {
    @Guide(description: "سؤال الاختبار")
    let question: String

    @Guide(description: "الإجابة الصحيحة على السؤال أعلاه")
    let correctAnswer: String

    @Guide(description: "شرح يوضح لماذا هذه هي الإجابة الصحيحة")
    let explanation: String
}

هنا correctAnswer يجي بعد question لأنه يعتمد عليه، و explanation يجي أخيرًا لأنه يعتمد على كليهما. تفصيلة صغيرة لكنها تأثيرها كبير على جودة المخرجات.

البث المباشر: عرض الاستجابات فوريًا في SwiftUI

في التطبيقات الحقيقية، ما أحد يبي ينتظر حتى يكتمل توليد النص بالكامل ثم يظهر دفعة وحدة. المستخدمين اعتادوا على تجربة ChatGPT حيث النص يظهر كلمة بكلمة — وهذا بالضبط اللي يوفّره إطار Foundation Models عبر البث المباشر (Streaming).

البث المباشر للنصوص

struct StreamingChatView: View {
    @State private var session = LanguageModelSession()
    @State private var input = ""
    @State private var output = ""
    @State private var isResponding = false

    var body: some View {
        VStack {
            ScrollView {
                Text(output)
                    .padding()
                    .frame(maxWidth: .infinity, alignment: .leading)
            }

            HStack {
                TextField("اسأل أي شيء...", text: $input)
                    .textFieldStyle(.roundedBorder)
                    .disabled(isResponding)

                Button("إرسال") {
                    Task { await streamResponse() }
                }
                .disabled(isResponding || input.isEmpty)
            }
            .padding()
        }
    }

    private func streamResponse() async {
        isResponding = true
        output = ""
        let prompt = input
        input = ""

        do {
            let stream = session.streamResponse(to: prompt)
            for try await partialResponse in stream {
                output = partialResponse
            }
        } catch {
            output = "حدث خطأ: \(error.localizedDescription)"
        }

        isResponding = false
    }
}

الفرق الجوهري: بدل respond(to:) نستخدم streamResponse(to:) اللي يُرجع AsyncSequence. كل عنصر في التسلسل هو النص المُولّد حتى اللحظة. بسيط وفعّال.

البث المباشر مع التوليد الموجّه

وهنا الموضوع يصير مثير فعلًا! تقدر تبث هياكل @Generable بشكل تدريجي:

@Generable
struct ArticleSummary {
    @Guide(description: "عنوان المقال")
    let title: String

    @Guide(description: "ملخص المقال في فقرة واحدة")
    let summary: String

    @Guide(description: "الكلمات المفتاحية", .count(3...5))
    let keywords: [String]
}

// بث تدريجي للهيكل
let stream = session.streamResponse(
    to: "لخّص لي مقالًا عن الذكاء الاصطناعي في التعليم",
    generating: ArticleSummary.self
)

for try await partial in stream {
    // partial هو من نوع ArticleSummary.PartiallyGenerated
    // الخصائص تبدأ بـ nil وتمتلئ تدريجيًا
    if let title = partial.title {
        print("العنوان: \(title)")
    }
    if let summary = partial.summary {
        print("الملخص: \(summary)")
    }
}

// الحصول على النتيجة النهائية الكاملة
let finalResult = try await stream.collect()
print(finalResult.content.title)

النقطة المهمة هنا: عند بث هيكل @Generable، الإطار ما يُرسل رموز خام (tokens) — بل يُرسل نسخ جزئية من الهيكل نفسه من نوع PartiallyGenerated. كل خاصية تبدأ بقيمة nil وتمتلئ تدريجيًا. هذا يخلّيك تحرّك واجهة SwiftUI بسلاسة أثناء ظهور البيانات — تجربة مستخدم ممتازة بأقل جهد.

استدعاء الأدوات: توسيع قدرات النموذج

النموذج اللغوي على الجهاز ذكي، لكنه ما يعرف كل شي. ما يعرف حالة الطقس الحالية، وما يقدر يوصل لقاعدة بيانات تطبيقك، وما يستطيع يرسل إشعار للمستخدم.

هنا يجي دور استدعاء الأدوات (Tool Calling).

الفكرة ببساطة: أنت تُعرّف "أداة" ووظيفتها، والنموذج يقرر بنفسه متى يستخدمها بناءً على سياق المحادثة. يعني أنت تعطيه الأدوات وهو يختار الوقت المناسب لاستخدامها — ذكي، صح؟

بناء أداة مخصصة: بروتوكول Tool

كل أداة تلتزم ببروتوكول Tool:

import FoundationModels

struct WeatherTool: Tool {
    let name = "get_weather"
    let description = "يجلب معلومات الطقس الحالية لمدينة محددة"

    @Generable
    struct Arguments {
        @Guide(description: "اسم المدينة المراد معرفة طقسها")
        let city: String
    }

    func call(arguments: Arguments) async throws -> String {
        // هنا تستدعي WeatherKit أو أي API طقس
        let weather = await fetchWeather(for: arguments.city)
        return "الطقس في \(arguments.city): \(weather.temperature)°م، \(weather.condition)"
    }

    private func fetchWeather(for city: String) async -> (temperature: Int, condition: String) {
        // محاكاة استدعاء API — في التطبيق الحقيقي استخدم WeatherKit
        return (32, "مشمس")
    }
}

لاحظ إن Arguments نفسها مُعلّمة بـ @Generable — لأن النموذج يستخدم التوليد الموجّه لإنتاج معاملات الأداة. وهذا يضمن إن النموذج ما ينتج أبدًا معاملات غير صالحة. ذكاء في التصميم بصراحة.

استخدام الأداة في جلسة

// إنشاء جلسة مع الأداة
let session = LanguageModelSession(tools: [WeatherTool()])

// النموذج يقرر تلقائيًا متى يستدعي الأداة
let response = try await session.respond(
    to: "هل الجو حار في القاهرة اليوم؟"
)
print(response.content)
// النموذج سيستدعي WeatherTool تلقائيًا، ثم يصوغ الإجابة

العملية تسير هكذا: المستخدم يسأل عن الطقس ← النموذج يُدرك إنه يحتاج بيانات الطقس ← يستدعي WeatherTool تلقائيًا مع المعاملات المناسبة ← يحصل على النتيجة ← يصوغ إجابة طبيعية للمستخدم. كل هذا يحصل تحت الغطاء بدون أي تدخل منك.

مثال متقدم: أدوات متعددة معًا

struct ContactSearchTool: Tool {
    let name = "search_contacts"
    let description = "يبحث في جهات الاتصال عن شخص بالاسم"

    @Generable
    struct Arguments {
        @Guide(description: "اسم الشخص المراد البحث عنه")
        let name: String
    }

    func call(arguments: Arguments) async throws -> String {
        // البحث في جهات الاتصال
        return "تم العثور على: \(arguments.name) - 0501234567"
    }
}

struct ReminderTool: Tool {
    let name = "create_reminder"
    let description = "ينشئ تذكيرًا جديدًا بمهمة محددة"

    @Generable
    struct Arguments {
        @Guide(description: "نص التذكير")
        let text: String

        @Guide(description: "الوقت بتنسيق HH:mm")
        let time: String
    }

    func call(arguments: Arguments) async throws -> String {
        return "تم إنشاء تذكير: \(arguments.text) في الساعة \(arguments.time)"
    }
}

// جلسة بأدوات متعددة
let session = LanguageModelSession(
    instructions: "أنت مساعد شخصي ذكي يمكنه البحث في جهات الاتصال وإنشاء تذكيرات.",
    tools: [ContactSearchTool(), ReminderTool()]
)

let response = try await session.respond(
    to: "ذكّرني أتصل بأحمد الساعة 3 بعد الظهر"
)

الإطار يتعامل تلقائيًا مع استدعاءات الأدوات المتوازية والمتسلسلة. لو النموذج احتاج يستدعي أداتين بنفس الوقت، يسوّي كذا بكفاءة بدون تدخل منك.

النماذج المتخصصة: المحوّلات (Adapters)

بالإضافة إلى النموذج الافتراضي العام، يوفّر الإطار نماذج متخصصة عبر SystemLanguageModel.UseCase:

// النموذج الافتراضي — مناسب لتوليد المحتوى والأسئلة والأجوبة
let defaultModel = SystemLanguageModel.default

// نموذج متخصص في تصنيف المحتوى
let taggingModel = SystemLanguageModel(useCase: .contentTagging)

النموذج المتخصص في تصنيف المحتوى (contentTagging) مُحسّن لمهام مثل استخراج الكلمات المفتاحية، تصنيف النصوص حسب الموضوع، وتحليل المشاعر (sentiment analysis). جرّبه لمّا تحتاج دقة أعلى في مهام التصنيف — الفرق ملحوظ مقارنة بالنموذج العام.

التحقق من توفر النموذج

ليس كل جهاز يدعم Foundation Models، لذلك لازم تتحقق قبل الاستخدام:

let availability = SystemLanguageModel.default.availability

switch availability {
case .available:
    // النموذج جاهز للاستخدام
    print("النموذج متاح!")
case .unavailable(.deviceNotEligible):
    print("الجهاز لا يدعم Apple Intelligence")
case .unavailable(.appleIntelligenceNotEnabled):
    print("Apple Intelligence غير مُفعّل في الإعدادات")
case .unavailable(.modelNotReady):
    print("النموذج قيد التحميل — حاول مجددًا لاحقًا")
default:
    print("النموذج غير متاح حاليًا")
}

هذا التحقق ضروري لتجربة مستخدم سلسة. لا تفترض إن النموذج متاح دايمًا — قدّم بديل مناسب (مثل API سحابي) لمّا يكون غير متاح.

أفضل الممارسات والنصائح العملية

1. التسخين المسبق (Prewarm)

إذا كنت تعرف إن المستخدم بيتفاعل مع النموذج قريبًا، سخّن الجلسة مسبقًا لتقليل زمن الاستجابة الأولى:

let session = LanguageModelSession()

// تحميل النموذج مسبقًا مع بادئة اختيارية
try await session.prewarm(promptPrefix: "أنت مساعد ذكي")

هذي الخطوة تفرق كثير في تجربة المستخدم — الاستجابة الأولى تكون أسرع بشكل ملحوظ.

2. اجعل التعليمات واضحة ومحددة

مع التوليد الموجّه، تعليماتك ممكن تكون أبسط لأن الهيكل يتكفّل بتحديد التنسيق. ركّز على السلوك المطلوب بدل التنسيق.

3. تعامل مع الأخطاء بأناقة

do {
    let response = try await session.respond(to: userInput)
    // معالجة النجاح
} catch let error as LanguageModelSession.GenerationError {
    switch error {
    case .guardrailViolation:
        // النموذج رفض الطلب لأسباب أمنية
        showAlert("لا يمكن معالجة هذا الطلب")
    case .tokenLimitExceeded:
        // الطلب تجاوز حد الرموز المسموح
        showAlert("الطلب طويل جدًا، حاول تقصيره")
    default:
        showAlert("حدث خطأ غير متوقع")
    }
}

4. إعادة استخدام الجلسات بذكاء

أعد استخدام نفس الجلسة للمحادثات المتصلة (مثل chatbot)، وأنشئ جلسة جديدة للمهام المستقلة. كل جلسة تحتفظ بسجل المحادثة الكامل وهذا يستهلك ذاكرة ورموز. فلا تستخدم جلسة وحدة لكل شي — وزّع بذكاء.

5. اللغات المدعومة

حاليًا، النموذج يدعم: الإنجليزية، الفرنسية، الألمانية، الإيطالية، البرتغالية، الإسبانية، الصينية المبسطة، اليابانية، والكورية. اللغة العربية غير مدعومة رسميًا بعد (وهذا مؤسف صراحة)، لكن يمكن للنموذج يتعامل معها بشكل محدود عبر التعليمات. للتطبيقات الإنتاجية اللي تستهدف الجمهور العربي، الحل الأفضل هو نهج هجين يجمع بين Foundation Models وخدمة سحابية تدعم العربية بشكل كامل.

متى تستخدم Foundation Models ومتى تلجأ للسحابة؟

إطار Foundation Models مو بديل كامل لنماذج السحابة الكبيرة مثل GPT-4 أو Claude. لكل منهما مكانه:

المعيار	Foundation Models (على الجهاز)	نماذج السحابة
الحجم	~3 مليار معامل	مئات المليارات
التكلفة	مجاني	مدفوع حسب الاستخدام
الخصوصية	كاملة — البيانات على الجهاز	البيانات تُرسل للسحابة
الاتصال	لا يحتاج إنترنت	يحتاج إنترنت دائم
دعم اللغات	9 لغات حاليًا	عشرات اللغات
المهام المعقدة	مناسب للمهام البسيطة والمتوسطة	مناسب للمهام المعقدة جدًا

استخدم Foundation Models لمّا: تحتاج استجابة فورية بدون تأخير الشبكة، أو تتعامل مع بيانات حساسة، أو تبي ميزة ذكاء اصطناعي تشتغل بدون إنترنت، أو تحتاج توفّر تكلفة الاستدعاءات السحابية.

استخدم نماذج السحابة لمّا: تحتاج دقة أعلى في مهام معقدة جدًا، أو تحتاج دعم كامل للغة العربية، أو تحتاج معالجة نصوص طويلة جدًا، أو تستهدف أجهزة قديمة ما تدعم Apple Intelligence.

النهج الأذكى في أغلب الحالات هو الحل الهجين: استخدم Foundation Models كخط الدفاع الأول (سريع، مجاني، خاص)، وارجع للسحابة لمّا يكون النموذج المحلي مو كافي. هذا النهج يعطيك أفضل ما في العالمين.

الأسئلة الشائعة

هل يعمل إطار Foundation Models في محاكي iOS؟

لا. تحتاج جهاز حقيقي بشريحة Apple Silicon يدعم Apple Intelligence. للتطوير والاختبار، تقدر تستخدم ماكرو #Playground في Xcode 26 على جهاز Mac بشريحة Apple Silicon.

ما الفرق بين Foundation Models و Core ML؟

Core ML مصمم لتشغيل نماذج تعلم آلة مخصصة (تصنيف صور، التعرف على الكائنات، وغيرها) بينما Foundation Models يوفّر وصول لنموذج لغوي كبير جاهز للاستخدام. يعني Core ML تجيب نموذجك وتشغّله، أما Foundation Models فالنموذج جاهز وأنت بس تتكلم معاه.

هل يمكنني تدريب أو تخصيص نموذج Foundation Models؟

لا، ما تقدر تدرّب أو تضبط (fine-tune) النموذج. لكن تقدر توجّه سلوكه بقوة عبر تعليمات النظام (instructions)، والتوليد الموجّه (@Generable و @Guide)، واستدعاء الأدوات (Tool Calling). الثلاث آليات مع بعض تعطيك تحكم كبير في المخرجات.

ما هي الأجهزة المتوافقة مع Foundation Models؟

أي جهاز Apple يدعم Apple Intelligence ويعمل بنظام iOS 26 أو iPadOS 26 أو macOS Tahoe 26 أو visionOS 26. يشمل ذلك iPhone 16 وما بعده، iPad بشريحة M1 وما بعده، وأجهزة Mac بشريحة Apple Silicon.

هل Foundation Models مجاني فعلًا بلا حدود؟

نعم، مجاني بالكامل. لا تكلفة ولا حد لعدد الطلبات. النموذج يعمل على الجهاز ولا يتواصل مع أي خادم. بس تذكّر إن كل استدعاء يستهلك موارد الجهاز (المعالج والذاكرة)، فاستخدمه بذكاء ولا تُغرق المستخدم بطلبات متوازية ما لها داعي.