iOS CoreML Integration: Complete Ollama iPhone App Development Guide

# Install Ollama
brew install ollama

# Install Core ML Tools
pip install coremltools

import ollama
import coremltools as ct
from transformers import AutoTokenizer, AutoModelForCausalLM

# Load your Ollama model
model_name = "llama2:7b"  # Replace with your model
ollama_model = ollama.load(model_name)

# Export to ONNX format
ollama.export(
    model=model_name,
    format="onnx",
    output_path="./models/ollama_model.onnx"
)

import coremltools as ct

# Convert ONNX to CoreML
onnx_model_path = "./models/ollama_model.onnx"
coreml_model = ct.convert(
    model=onnx_model_path,
    inputs=[ct.TensorType(shape=(1, 512), dtype=np.int32)],
    outputs=[ct.TensorType(dtype=np.float32)],
    minimum_deployment_target=ct.target.iOS16
)

# Save CoreML model
coreml_model.save("./models/OllamaModel.mlmodel")

# Quantize model for smaller size
quantized_model = ct.models.neural_network.quantization_utils.quantize_weights(
    coreml_model, 
    nbits=8  # 8-bit quantization
)

# Set metadata
quantized_model.short_description = "Optimized Ollama model for iOS"
quantized_model.author = "Your Name"
quantized_model.version = "1.0"

# Final save
quantized_model.save("./models/OllamaModelOptimized.mlmodel")

// ContentView.swift
import SwiftUI
import CoreML

@main
struct OllamaApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

// OllamaModelManager.swift
import CoreML
import Foundation

class OllamaModelManager: ObservableObject {
    private var model: OllamaModelOptimized?
    @Published var isLoaded = false
    @Published var errorMessage: String?
    
    init() {
        loadModel()
    }
    
    private func loadModel() {
        do {
            // Load the CoreML model
            let config = MLModelConfiguration()
            config.computeUnits = .cpuAndGPU  // Use CPU and GPU
            
            self.model = try OllamaModelOptimized(configuration: config)
            self.isLoaded = true
            print("✅ Ollama CoreML model loaded successfully")
            
        } catch {
            self.errorMessage = "Failed to load model: \(error.localizedDescription)"
            print("❌ Model loading error: \(error)")
        }
    }
}

// TextProcessor.swift
import Foundation
import NaturalLanguage

class TextProcessor {
    private let maxTokens = 512
    
    func processInput(_ text: String) -> MLMultiArray? {
        // Tokenize input text
        let tokens = tokenize(text)
        
        // Convert to MLMultiArray
        guard let inputArray = try? MLMultiArray(
            shape: [1, NSNumber(value: tokens.count)],
            dataType: .int32
        ) else {
            print("❌ Failed to create input array")
            return nil
        }
        
        // Fill array with token values
        for (index, token) in tokens.enumerated() {
            inputArray[index] = NSNumber(value: token)
        }
        
        return inputArray
    }
    
    private func tokenize(_ text: String) -> [Int] {
        // Simple tokenization - replace with proper tokenizer
        let words = text.components(separatedBy: .whitespacesAndNewlines)
        return words.compactMap { word in
            // Convert words to token IDs (simplified)
            return word.hash % 10000  // Basic hash-based tokenization
        }
    }
}

// Extension to OllamaModelManager.swift
extension OllamaModelManager {
    func generateText(from prompt: String, completion: @escaping (String?) -> Void) {
        guard let model = self.model else {
            completion(nil)
            return
        }
        
        let processor = TextProcessor()
        guard let inputArray = processor.processInput(prompt) else {
            completion(nil)
            return
        }
        
        // Create model input
        guard let modelInput = try? OllamaModelOptimizedInput(
            input: inputArray
        ) else {
            completion(nil)
            return
        }
        
        // Run prediction asynchronously
        DispatchQueue.global(qos: .userInitiated).async {
            do {
                let prediction = try model.prediction(input: modelInput)
                let generatedText = self.processOutput(prediction.output)
                
                DispatchQueue.main.async {
                    completion(generatedText)
                }
            } catch {
                print("❌ Prediction error: \(error)")
                DispatchQueue.main.async {
                    completion(nil)
                }
            }
        }
    }
    
    private func processOutput(_ output: MLMultiArray) -> String {
        // Convert model output back to text
        // This is a simplified implementation
        let outputData = (0..<output.count).compactMap { index in
            output[index].floatValue
        }
        
        // Convert probabilities to text (simplified)
        return "Generated response based on model output"
    }
}

// ChatView.swift
import SwiftUI

struct ChatView: View {
    @StateObject private var modelManager = OllamaModelManager()
    @State private var inputText = ""
    @State private var messages: [ChatMessage] = []
    @State private var isGenerating = false
    
    var body: some View {
        NavigationView {
            VStack {
                // Chat Messages
                ScrollView {
                    LazyVStack(alignment: .leading, spacing: 12) {
                        ForEach(messages) { message in
                            ChatBubble(message: message)
                        }
                    }
                    .padding()
                }
                
                // Input Area
                HStack {
                    TextField("Type your message...", text: $inputText)
                        .textFieldStyle(RoundedBorderTextFieldStyle())
                        .disabled(isGenerating)
                    
                    Button("Send") {
                        sendMessage()
                    }
                    .disabled(inputText.isEmpty || isGenerating || !modelManager.isLoaded)
                }
                .padding()
            }
            .navigationTitle("Ollama Chat")
            .navigationBarTitleDisplayMode(.inline)
        }
        .overlay(
            // Loading indicator
            Group {
                if !modelManager.isLoaded {
                    VStack {
                        ProgressView()
                        Text("Loading Ollama model...")
                            .font(.caption)
                            .foregroundColor(.secondary)
                    }
                    .frame(maxWidth: .infinity, maxHeight: .infinity)
                    .background(Color.black.opacity(0.3))
                }
            }
        )
    }
    
    private func sendMessage() {
        let userMessage = ChatMessage(
            content: inputText,
            isUser: true,
            timestamp: Date()
        )
        
        messages.append(userMessage)
        let prompt = inputText
        inputText = ""
        isGenerating = true
        
        modelManager.generateText(from: prompt) { response in
            isGenerating = false
            
            if let response = response {
                let aiMessage = ChatMessage(
                    content: response,
                    isUser: false,
                    timestamp: Date()
                )
                messages.append(aiMessage)
            } else {
                // Handle error
                let errorMessage = ChatMessage(
                    content: "Sorry, I couldn't generate a response.",
                    isUser: false,
                    timestamp: Date()
                )
                messages.append(errorMessage)
            }
        }
    }
}

// ChatMessage.swift
import Foundation

struct ChatMessage: Identifiable {
    let id = UUID()
    let content: String
    let isUser: Bool
    let timestamp: Date
}

struct ChatBubble: View {
    let message: ChatMessage
    
    var body: some View {
        HStack {
            if message.isUser {
                Spacer()
            }
            
            VStack(alignment: message.isUser ? .trailing : .leading) {
                Text(message.content)
                    .padding(12)
                    .background(
                        message.isUser ? Color.blue : Color.gray.opacity(0.2)
                    )
                    .foregroundColor(
                        message.isUser ? .white : .primary
                    )
                    .cornerRadius(16)
                
                Text(message.timestamp, style: .time)
                    .font(.caption2)
                    .foregroundColor(.secondary)
            }
            
            if !message.isUser {
                Spacer()
            }
        }
    }
}

// MemoryOptimizer.swift
class MemoryOptimizer {
    static func optimizeForMobileDevice() {
        // Clear unnecessary caches
        URLCache.shared.removeAllCachedResponses()
        
        // Monitor memory usage
        let memoryInfo = getMemoryUsage()
        print("📊 Memory usage: \(memoryInfo.used)MB / \(memoryInfo.total)MB")
        
        if memoryInfo.used > memoryInfo.total * 0.8 {
            // Trigger garbage collection
            print("⚠️ High memory usage detected, optimizing...")
        }
    }
    
    private static func getMemoryUsage() -> (used: Double, total: Double) {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
        
        let result = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_,
                         task_flavor_t(MACH_TASK_BASIC_INFO),
                         $0,
                         &count)
            }
        }
        
        let usedMB = Double(info.resident_size) / 1024.0 / 1024.0
        let totalMB = Double(ProcessInfo.processInfo.physicalMemory) / 1024.0 / 1024.0
        
        return (usedMB, totalMB)
    }
}

// ModelCache.swift
class ModelCache {
    private static let cacheDirectory = FileManager.default.urls(
        for: .cachesDirectory,
        in: .userDomainMask
    ).first!.appendingPathComponent("OllamaModels")
    
    static func cacheModel(_ data: Data, withName name: String) {
        do {
            try FileManager.default.createDirectory(
                at: cacheDirectory,
                withIntermediateDirectories: true
            )
            
            let fileURL = cacheDirectory.appendingPathComponent("\(name).cache")
            try data.write(to: fileURL)
            
            print("✅ Model cached successfully: \(name)")
        } catch {
            print("❌ Failed to cache model: \(error)")
        }
    }
    
    static func loadCachedModel(withName name: String) -> Data? {
        let fileURL = cacheDirectory.appendingPathComponent("\(name).cache")
        
        do {
            let data = try Data(contentsOf: fileURL)
            print("✅ Loaded cached model: \(name)")
            return data
        } catch {
            print("ℹ️ No cached model found: \(name)")
            return nil
        }
    }
}

// OllamaModelTests.swift
import XCTest
@testable import OllamaApp

final class OllamaModelTests: XCTestCase {
    var modelManager: OllamaModelManager!
    
    override func setUpWithError() throws {
        modelManager = OllamaModelManager()
        
        // Wait for model to load
        let expectation = XCTestExpectation(description: "Model loading")
        
        DispatchQueue.main.asyncAfter(deadline: .now() + 5) {
            if self.modelManager.isLoaded {
                expectation.fulfill()
            }
        }
        
        wait(for: [expectation], timeout: 10)
    }
    
    func testModelLoading() throws {
        XCTAssertTrue(modelManager.isLoaded, "Model should be loaded successfully")
        XCTAssertNil(modelManager.errorMessage, "No error message should be present")
    }
    
    func testTextGeneration() throws {
        let expectation = XCTestExpectation(description: "Text generation")
        
        modelManager.generateText(from: "Hello, how are you?") { response in
            XCTAssertNotNil(response, "Response should not be nil")
            XCTAssertFalse(response!.isEmpty, "Response should not be empty")
            expectation.fulfill()
        }
        
        wait(for: [expectation], timeout: 30)
    }
    
    func testPerformance() throws {
        measure {
            let expectation = XCTestExpectation(description: "Performance test")
            
            modelManager.generateText(from: "Test prompt") { _ in
                expectation.fulfill()
            }
            
            wait(for: [expectation], timeout: 10)
        }
    }
}

// Logger.swift
import Foundation
import os.log

class OllamaLogger {
    static let shared = OllamaLogger()
    private let logger = Logger(subsystem: "com.yourapp.ollama", category: "CoreML")
    
    private init() {}
    
    func debug(_ message: String) {
        logger.debug("\(message)")
        print("🐛 DEBUG: \(message)")
    }
    
    func info(_ message: String) {
        logger.info("\(message)")
        print("ℹ️ INFO: \(message)")
    }
    
    func error(_ message: String) {
        logger.error("\(message)")
        print("❌ ERROR: \(message)")
    }
    
    func performance(_ operation: String, duration: TimeInterval) {
        let message = "\(operation) completed in \(String(format: "%.2f", duration))s"
        logger.info("\(message)")
        print("⚡ PERFORMANCE: \(message)")
    }
}

// Usage example
extension OllamaModelManager {
    private func logPerformance<T>(_ operation: String, block: () throws -> T) rethrows -> T {
        let startTime = Date()
        let result = try block()
        let duration = Date().timeIntervalSince(startTime)
        OllamaLogger.shared.performance(operation, duration: duration)
        return result
    }
}

// ModelTroubleshooter.swift
class ModelTroubleshooter {
    static func diagnoseModelIssues() {
        // Check device compatibility
        if !isDeviceCompatible() {
            print("❌ Device not compatible with CoreML")
            return
        }
        
        // Check model file existence
        guard let modelPath = Bundle.main.path(forResource: "OllamaModelOptimized", ofType: "mlmodel") else {
            print("❌ Model file not found in bundle")
            return
        }
        
        // Check model file size
        let fileSize = getFileSize(at: modelPath)
        print("📊 Model file size: \(fileSize)MB")
        
        if fileSize > 100 {
            print("⚠️ Large model detected - consider optimization")
        }
        
        // Validate model format
        validateModelFormat(at: modelPath)
    }
    
    private static func isDeviceCompatible() -> Bool {
        guard #available(iOS 16.0, *) else {
            print("❌ iOS 16.0+ required")
            return false
        }
        
        // Check for Neural Engine availability
        return MLModel.availableComputeDevices.contains(.neuralEngine)
    }
    
    private static func getFileSize(at path: String) -> Double {
        do {
            let attributes = try FileManager.default.attributesOfItem(atPath: path)
            let fileSize = attributes[.size] as! UInt64
            return Double(fileSize) / 1024.0 / 1024.0  // Convert to MB
        } catch {
            return 0
        }
    }
    
    private static func validateModelFormat(at path: String) {
        do {
            let model = try MLModel(contentsOf: URL(fileURLWithPath: path))
            print("✅ Model validation successful")
            print("📋 Model description: \(model.modelDescription)")
        } catch {
            print("❌ Model validation failed: \(error)")
        }
    }
}

// ErrorHandler.swift
enum OllamaError: LocalizedError {
    case modelNotLoaded
    case invalidInput
    case predictionFailed(Error)
    case memoryLimitExceeded
    
    var errorDescription: String? {
        switch self {
        case .modelNotLoaded:
            return "CoreML model is not loaded. Please check model file."
        case .invalidInput:
            return "Input format is invalid. Check tokenization process."
        case .predictionFailed(let error):
            return "Prediction failed: \(error.localizedDescription)"
        case .memoryLimitExceeded:
            return "Memory limit exceeded. Try reducing model size."
        }
    }
    
    var recoverySuggestion: String? {
        switch self {
        case .modelNotLoaded:
            return "Verify model file exists in app bundle and device is compatible."
        case .invalidInput:
            return "Check input text processing and tokenization logic."
        case .predictionFailed:
            return "Review model configuration and input parameters."
        case .memoryLimitExceeded:
            return "Use model quantization or reduce batch size."
        }
    }
}

// BuildConfig.swift
struct BuildConfig {
    #if DEBUG
    static let isDebug = true
    static let modelVersion = "debug-1.0"
    #else
    static let isDebug = false
    static let modelVersion = "release-1.0"
    #endif
    
    static let minimumIOSVersion = "16.0"
    static let requiredMemoryMB = 4096
    static let recommendedMemoryMB = 8192
}