Swift原生Ollama客户端库：简化本地大模型集成与流式对话开发

1. 项目概述：为什么我们需要一个原生的 Ollama 客户端库？

如果你最近在本地机器上折腾过大语言模型，那么“Ollama”这个名字对你来说一定不陌生。它就像一个魔法盒，让你能在自己的电脑上轻松运行 Llama、Mistral、CodeLlama 等一众开源大模型，无需复杂的云端 API 配置和昂贵的费用。但当你兴奋地下载了 Ollama，启动服务，准备在自己的 Swift 或 SwiftUI 应用中集成这个强大的本地 AI 引擎时，你可能会发现一个尴尬的现实：官方并没有提供一个现成的、优雅的 Swift 客户端库。你面对的，是赤裸裸的 HTTP API 文档。

这意味着什么？意味着你需要自己手动去构造 HTTP 请求，处理 JSON 的序列化与反序列化，管理网络连接状态，处理各种可能的错误……这些底层工作虽然不难，但极其繁琐，且容易出错。它分散了你本应聚焦在应用逻辑和用户体验上的精力。kevinhermawan/OllamaKit正是为了解决这个痛点而生的。它是一个用纯 Swift 编写的、非官方的 Ollama API 客户端库，其目标非常明确：为 Swift 开发者提供一个类型安全、易于使用、与 Swift 生态（特别是 SwiftUI）无缝集成的工具，让你能用几行代码就完成与本地 Ollama 服务的所有交互。

简单来说，它把 Ollama 的 HTTP API 包装成了你熟悉的 Swift 对象和方法。你想拉取模型列表？调用OKModelResponse。你想和模型对话？使用OKChatRequest和OKChatResponse。它处理了所有底层的网络通信、数据编码和错误处理，让你可以像调用本地函数一样与 AI 模型交互。这对于正在构建 macOS 原生 AI 应用、iOS/iPadOS 上的研究工具，或者任何需要集成本地大模型能力的 Swift 项目来说，无疑是一把利器。它降低了集成门槛，让开发者能更快速地将创意落地。

2. 核心架构与设计哲学拆解

2.1 面向协议与泛型的现代化 Swift 设计

打开OllamaKit的源码，你能立刻感受到一股浓郁的现代 Swift 风格。它没有采用陈旧的回调（Completion Handler）模式，而是全面拥抱了 Swift 的async/await并发模型。这意味着所有网络请求都是异步的，你的代码可以写得像同步代码一样清晰，无需陷入“回调地狱”。例如，获取模型列表的代码看起来会是这样：

let ollamaKit = OllamaKit(baseURL: URL(string: "http://localhost:11434")!) do { let models = try await ollamaKit.models() print("本地可用模型: \(models.models)") } catch { print("请求失败: \(error)") }

这种设计不仅让代码更易读，也更好地利用了 Swift 的结构化并发特性，便于进行错误传播和任务管理。

其次，库的核心是围绕OllamaKit这个主结构体构建的，它遵循了“单一职责原则”。它不负责具体的网络实现，而是依赖一个OKHTTPSession协议。这个设计非常巧妙，它允许你注入自定义的网络层。比如，在单元测试中，你可以轻松地注入一个模拟的MockHTTPSession来返回预设的数据，而无需启动真实的 Ollama 服务。这种面向协议的设计极大地提升了代码的可测试性和灵活性。

在数据模型方面，OllamaKit为每一个 Ollama API 端点定义了对应的 Swift 结构体（struct）。例如，OKModelResponse对应/api/tags的响应，OKChatRequest和OKChatResponse对应/api/chat。这些结构体都遵循Codable协议，库内部使用JSONEncoder和JSONDecoder进行自动的序列化和反序列化。这带来了完美的类型安全：编译器会在你编码时检查字段类型，避免了手动拼接 JSON 字符串时可能出现的拼写错误或类型不匹配问题。

2.2 对 Streaming（流式响应）的优雅支持

与大模型交互时，流式响应（Streaming）是提升用户体验的关键。想象一下，如果模型生成一段长文本需要10秒钟，在非流式模式下，你的应用会卡住10秒，然后突然显示全部结果。而在流式模式下，模型会像真人打字一样，一个字一个字地“流”出来，用户可以实时看到生成过程，体验流畅得多。

Ollama 的 API 原生支持流式响应，OllamaKit对此做了精心的封装。它没有简单地返回一个完整的OKChatResponse，而是提供了一个返回AsyncThrowingStream<OKChatResponse, Error>的方法。AsyncThrowingStream是 Swift 并发框架中用于处理异步数据流的强大工具。你可以这样使用它：

let request = OKChatRequest(model: "llama3.2", messages: [.init(role: .user, content: "你好，请介绍一下你自己。")], stream: true) do { let stream = try await ollamaKit.chat(request) for try await chunk in stream { if let content = chunk.message?.content { // 实时更新UI，显示最新的内容 print(content, terminator: "") } if chunk.done { print("\n--- 生成完成 ---") break } } } catch { print("流式请求出错: \(error)") }

这段代码创建了一个请求，并指定stream: true。然后，它通过for try await...in循环来消费这个流。每一次循环，chunk变量就代表服务器推送过来的一个数据块（通常是几个 token 对应的文本）。你可以立即用这个块来更新你的 UI（比如 SwiftUI 的@Published状态），实现实时的打字机效果。当chunk.done为true时，表示整个响应已结束。这种设计将复杂的流式网络处理抽象成了一个简单的异步序列，是库中非常亮眼的一处设计。

2.3 错误处理与可扩展性考量

一个健壮的库必须有良好的错误处理。OllamaKit定义了自己的错误类型OllamaKitError，它涵盖了网络错误、解码错误、无效响应等常见情况。通过async/await，这些错误可以自然地沿着调用链向上抛出，由调用者决定如何处理（例如，在 UI 层显示一个警告框）。

此外，库的架构考虑到了 Ollama API 的未来扩展。目前它覆盖了核心的模型管理、对话、生成和嵌入（Embedding）接口。如果 Ollama 未来增加了新的 API 端点（比如模型微调接口），OllamaKit的维护者可以很容易地遵循现有模式添加新的结构体和方法，而不会破坏现有的 API。对于使用者来说，这种一致性也降低了学习成本。

注意：虽然OllamaKit封装得很好，但它本质上是一个客户端，其稳定性和功能上限取决于 Ollama 服务本身。如果 Ollama 服务未运行、端口被占用或版本不兼容，库抛出的错误最终都会追溯到网络层面。因此，在你的应用中，初始化OllamaKit实例前，最好先有一个健康检查机制，例如尝试一个简单的GET请求到/api/tags，以确保服务可用。

3. 从零开始集成：实战步骤详解

3.1 环境准备与依赖管理

假设我们要创建一个全新的 macOS 控制台应用来演示OllamaKit的完整能力。首先，确保你的开发环境就绪：

1. Xcode 15+：确保安装了最新版本的 Xcode，因为它包含最新的 Swift 工具链和对 Swift Concurrency 的完整支持。
2. Ollama 服务：前往 Ollama 官网 下载并安装。安装完成后，在终端执行ollama serve来启动服务。默认情况下，它会在http://localhost:11434监听请求。你可以通过ollama pull llama3.2来拉取一个模型，确保服务有模型可用。
3. 新建项目：打开 Xcode，选择 “File” -> “New” -> “Project…”，选择 “macOS” 标签下的 “Command Line Tool”，命名为 “OllamaKitDemo”。语言选择 Swift。

接下来是集成OllamaKit。由于它是一个 Swift Package，我们可以直接用 Swift Package Manager (SPM) 来管理依赖，这是最推荐的方式。

在 Xcode 中，点击项目导航器顶部的项目名称，选择 “Package Dependencies” 标签页，点击 “+” 按钮。在搜索框中输入https://github.com/kevinhermawan/OllamaKit.git，点击 “Add Package”。Xcode 会解析仓库，通常直接点击 “Add Package” 按钮即可完成添加。SPM 会自动处理依赖的下载和链接。

如果你想通过Package.swift文件管理（对于更复杂的项目），可以在dependencies数组中添加：

dependencies: [ .package(url: "https://github.com/kevinhermawan/OllamaKit.git", from: "0.1.0") ]

然后在你目标的dependencies里添加"OllamaKit"。

3.2 基础功能调用：模型管理与单次对话

让我们先实现两个最基本的功能：列出所有本地模型，并进行一次非流式的简单对话。打开main.swift文件，替换其内容：

import OllamaKit import Foundation @main struct OllamaKitDemo { static func main() async { // 1. 初始化客户端，指向本地运行的 Ollama 服务 let baseURL = URL(string: "http://localhost:11434")! let ollamaKit = OllamaKit(baseURL: baseURL) // 2. 获取模型列表 print("正在获取本地模型列表...") do { let modelResponse = try await ollamaKit.models() print("✅ 获取成功！") print("本地共有 \(modelResponse.models.count) 个模型:") for model in modelResponse.models { print(" - \(model.name) (大小: \(model.size) 字节， 修改于: \(model.modifiedAt))") } // 3. 使用第一个模型进行单次对话（非流式） if let firstModel = modelResponse.models.first { print("\n--- 开始与模型 '\(firstModel.name)' 对话 ---") let chatRequest = OKChatRequest( model: firstModel.name, messages: [ OKChatMessage(role: .user, content: "用简短的一句话介绍法国的首都。") ], stream: false // 关键：关闭流式 ) let chatResponse = try await ollamaKit.chat(chatRequest) if let assistantMessage = chatResponse.message { print("模型回复: \(assistantMessage.content)") } print("本次生成消耗了 \(chatResponse.evalCount ?? 0) 个 token，耗时 \(chatResponse.totalDuration ?? 0) 纳秒。") } else { print("⚠️ 没有找到可用的模型，请先使用 `ollama pull` 命令拉取一个模型。") } } catch { print("❌ 操作失败: \(error)") } } }

这段代码清晰地展示了库的基础用法：

1. 初始化：创建OllamaKit实例，这是所有操作的起点。
2. 获取模型：调用异步的models()方法。它会向/api/tags发送请求，并将返回的 JSON 自动解析成OKModelResponse对象。
3. 发起对话：构造一个OKChatRequest对象，其中包含模型名、消息历史（这里只有一条用户消息）以及stream: false。然后调用chat(_:)方法。该方法会等待模型生成完整的回复后，一次性返回OKChatResponse。

运行这个程序（Cmd+R），如果一切正常，你会先在终端看到模型列表，然后看到模型对巴黎的简介。注意控制台输出的统计信息（evalCount,totalDuration），这些对于评估模型性能和成本（虽然本地运行成本主要是电费和算力）很有帮助。

3.3 实现流式对话与实时 UI 更新

基础对话体验不错，但真正的魅力在于流式响应。我们将改造上面的程序，使其支持流式输出，并模拟一个更复杂的对话场景。同时，为了更贴近真实应用，我们引入一个简单的“对话历史”管理。

import OllamaKit import Foundation @main struct OllamaKitDemo { static func main() async { let ollamaKit = OllamaKit(baseURL: URL(string: "http://localhost:11434")!) // 模拟一个对话历史 var conversationHistory: [OKChatMessage] = [] // 系统提示词，可以引导模型行为 let systemPrompt = OKChatMessage(role: .system, content: "你是一个乐于助人且知识渊博的助手。回答要简洁明了。") conversationHistory.append(systemPrompt) let userQuestion = "请为我解释一下量子计算的基本原理，以及它和经典计算的主要区别。" print("用户: \(userQuestion)\n") conversationHistory.append(OKChatMessage(role: .user, content: userQuestion)) let chatRequest = OKChatRequest( model: "llama3.2", // 明确指定一个模型，确保已拉取 messages: conversationHistory, stream: true // 关键：开启流式 ) print("助手: ", terminator: "") var fullResponse = "" do { let stream = try await ollamaKit.chat(chatRequest) for try await chunk in stream { // 处理流式数据块 if let content = chunk.message?.content { print(content, terminator: "") fullResponse.append(content) } // 可以在这里处理其他信息，如生成状态 if let evalCount = chunk.evalCount { // print(" [已生成 token: \(evalCount)]") // 调试用 } if chunk.done { // 流结束，将完整的助手回复加入历史 let assistantMessage = OKChatMessage(role: .assistant, content: fullResponse) conversationHistory.append(assistantMessage) print("\n\n--- 流式生成完成 ---") // 可以继续下一轮对话... } } } catch { print("\n❌ 流式对话出错: \(error)") } } }

这段代码的改进点：

• 对话历史：我们维护了一个conversationHistory数组。在真实聊天应用中，这个数组就是整个会话的上下文。每次用户提问和助手回答后，都需要将对应的消息追加进去，这样在下一轮对话时，模型才能拥有完整的上下文记忆。
• 系统提示：我们添加了一条role: .system的消息。系统提示词是引导模型行为的有力工具，你可以在这里设定模型的角色、回答风格、禁忌等。
• 流式处理：核心是for try await chunk in stream循环。它异步地等待并处理每一个从服务器推送过来的数据块。terminator: ""参数让print不换行，从而实现字符逐个输出的效果。我们将每个块的内容累加到fullResponse中，并在流结束时，构造一条完整的助手消息存入历史。

实操心得：在实际的 SwiftUI 应用中，你会将fullResponse绑定到一个@State或@Published属性上。SwiftUI 的视图会随着这个属性的更新而自动刷新，从而实现完美的实时打字机效果。OllamaKit返回的AsyncThrowingStream与 SwiftUI 的.task修饰符或AsyncImage等异步数据源的处理模式高度一致，集成起来非常顺畅。

3.4 高级功能探索：生成与嵌入

除了聊天，Ollama 还提供了原始的“生成”（Generate）和“嵌入”（Embeddings）接口，OllamaKit也对此进行了封装。

生成（Generate）接口：这个接口更底层，它不区分用户和助手角色，只是接收一段提示词（Prompt）并让模型续写。适用于一些非对话场景，比如文本补全、大纲生成等。

let generateRequest = OKGenerateRequest(model: "llama3.2", prompt: "给我写一首关于春天的五言绝句：", stream: false) do { let generateResponse = try await ollamaKit.generate(generateRequest) print("生成结果: \(generateResponse.response)") } catch { print("生成失败: \(error)") }

嵌入（Embeddings）接口：这是将文本转换为高维向量（一组浮点数）的接口。生成的向量可以用于语义搜索、文本分类、聚类等机器学习任务。OllamaKit提供了OKEmbeddingsRequest和OKEmbeddingsResponse。

let embedRequest = OKEmbeddingsRequest(model: "llama3.2", prompt: "机器学习是人工智能的一个分支。") do { let embedResponse = try await ollamaKit.embeddings(embedRequest) let embeddingVector = embedResponse.embedding print("文本的嵌入向量维度: \(embeddingVector.count)") // 你可以计算这个向量与其他文本向量的余弦相似度，来判断语义相关性。 } catch { print("获取嵌入失败: \(error)") }

注意事项：不同模型产生的嵌入向量维度可能不同，且不同模型生成的向量空间并不直接可比。在进行语义相似度比较时，务必使用同一个模型生成的嵌入。

4. 在 SwiftUI 应用中构建一个简易聊天客户端

理论说得再多，不如动手实践。让我们用 SwiftUI 构建一个极简的、与本地 Ollama 对话的 macOS 应用。这个例子将展示如何将OllamaKit与 SwiftUI 的响应式编程模型结合。

步骤 1：创建 SwiftUI 项目在 Xcode 中新建一个 “macOS” -> “App” 项目，命名为 “OllamaChat”。语言选择 Swift，界面选择 SwiftUI。

步骤 2：添加依赖同上文，通过 SPM 添加OllamaKit依赖。

步骤 3：构建数据模型和视图模型首先，我们定义一个代表单条消息的数据模型：

// Message.swift import Foundation struct Message: Identifiable, Equatable { let id = UUID() let role: Role var content: String let timestamp = Date() enum Role { case user case assistant } }

然后，创建一个负责业务逻辑的视图模型（ViewModel）。它将是ObservableObject，管理应用状态和与OllamaKit的交互。

// ChatViewModel.swift import Foundation import OllamaKit import SwiftUI @MainActor class ChatViewModel: ObservableObject { @Published var messages: [Message] = [] @Published var currentInput: String = "" @Published var isResponding: Bool = false @Published var selectedModel: String = "llama3.2" @Published var availableModels: [String] = [] private var ollamaKit: OllamaKit private var conversationHistory: [OKChatMessage] = [] init() { // 初始化客户端，假设 Ollama 运行在本地默认端口 self.ollamaKit = OllamaKit(baseURL: URL(string: "http://localhost:11434")!) // 可以在这里添加一个系统提示 conversationHistory.append(OKChatMessage(role: .system, content: "你是一个有用的助手。")) Task { await fetchAvailableModels() } } func fetchAvailableModels() async { do { let response = try await ollamaKit.models() availableModels = response.models.map { $0.name }.sorted() if !availableModels.isEmpty && selectedModel.isEmpty { selectedModel = availableModels[0] } } catch { print("获取模型失败: \(error)") // 可以在这里更新UI状态，提示用户服务未启动 } } func sendMessage() async { let userMessage = currentInput.trimmingCharacters(in: .whitespacesAndNewlines) guard !userMessage.isEmpty, !isResponding else { return } // 更新UI：添加用户消息，清空输入框 let userMsgObj = Message(role: .user, content: userMessage) messages.append(userMsgObj) conversationHistory.append(OKChatMessage(role: .user, content: userMessage)) currentInput = "" // 准备助手消息占位符，并开始生成 let assistantMsgId = UUID() let assistantMsgObj = Message(role: .assistant, content: "") messages.append(assistantMsgObj) isResponding = true let chatRequest = OKChatRequest(model: selectedModel, messages: conversationHistory, stream: true) do { let stream = try await ollamaKit.chat(chatRequest) var fullContent = "" for try await chunk in stream { if let content = chunk.message?.content { // 更新流式内容 fullContent.append(content) // 找到占位符消息并更新其内容 if let index = messages.firstIndex(where: { $0.id == assistantMsgId }) { messages[index].content = fullContent } } if chunk.done { // 流结束，将完整回复加入历史 conversationHistory.append(OKChatMessage(role: .assistant, content: fullContent)) isResponding = false break } } } catch { // 处理错误：更新占位符消息为错误信息 if let index = messages.firstIndex(where: { $0.id == assistantMsgId }) { messages[index].content = "抱歉，请求出错: \(error.localizedDescription)" } isResponding = false } } }

步骤 4：构建 SwiftUI 视图现在，创建主视图来展示聊天界面：

// ContentView.swift import SwiftUI struct ContentView: View { @StateObject private var viewModel = ChatViewModel() var body: some View { VStack(spacing: 0) { // 顶部模型选择器 HStack { Picker("选择模型", selection: $viewModel.selectedModel) { ForEach(viewModel.availableModels, id: \.self) { model in Text(model).tag(model) } } .pickerStyle(MenuPickerStyle()) .frame(width: 200) .disabled(viewModel.isResponding) Button("刷新模型列表") { Task { await viewModel.fetchAvailableModels() } } .disabled(viewModel.isResponding) Spacer() Text(viewModel.isResponding ? "思考中..." : "就绪") .foregroundColor(.secondary) } .padding() .background(Color(NSColor.controlBackgroundColor)) // 消息列表 ScrollViewReader { proxy in ScrollView { LazyVStack(alignment: .leading, spacing: 12) { ForEach(viewModel.messages) { message in MessageBubble(message: message) .id(message.id) // 用于滚动到底部 } } .padding() } .onChange(of: viewModel.messages.last?.id) { _ in // 当有新消息时，滚动到底部 withAnimation { if let lastId = viewModel.messages.last?.id { proxy.scrollTo(lastId, anchor: .bottom) } } } } // 底部输入区域 HStack { TextField("输入消息...", text: $viewModel.currentInput, axis: .vertical) .textFieldStyle(RoundedBorderTextFieldStyle()) .lineLimit(3...10) // 允许最多10行 .disabled(viewModel.isResponding) .onSubmit { // 支持按回车发送（Cmd+Enter 是换行） Task { await viewModel.sendMessage() } } Button(action: { Task { await viewModel.sendMessage() } }) { Image(systemName: "paperplane.fill") } .keyboardShortcut(.return, modifiers: .command) // Cmd+Enter 发送 .disabled(viewModel.currentInput.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || viewModel.isResponding) } .padding() } .frame(minWidth: 500, minHeight: 600) } } // 消息气泡子视图 struct MessageBubble: View { let message: Message var body: some View { HStack { if message.role == .user { Spacer() } VStack(alignment: .leading, spacing: 4) { Text(message.role == .user ? "你" : "助手") .font(.caption) .foregroundColor(.secondary) Text(message.content) .textSelection(.enabled) // 允许选择文本 .padding(.horizontal, 12) .padding(.vertical, 8) .background(message.role == .user ? Color.blue.opacity(0.2) : Color.gray.opacity(0.2)) .cornerRadius(12) } if message.role == .assistant { Spacer() } } } }

步骤 5：运行与测试现在运行这个应用（Cmd+R）。确保你的 Ollama 服务正在后台运行（ollama serve）。应用启动后会尝试获取模型列表。在输入框中键入问题，按Cmd+Enter或点击发送按钮，你就能看到模型以流式的方式，一个字一个字地回复在界面上了。

这个简易客户端涵盖了核心功能：模型选择、流式对话、历史管理、基本的错误处理。你可以在此基础上继续扩展，比如添加对话历史持久化（使用@AppStorage或 Core Data）、支持多轮对话、实现模型参数（如temperature,top_p）调节、添加 Markdown 渲染等等。

5. 常见问题、性能调优与进阶思考

5.1 问题排查与常见错误

在实际集成OllamaKit时，你可能会遇到以下典型问题：

5.2 性能调优与最佳实践

1. 连接池与超时设置：OllamaKit底层使用URLSession。对于高频调用的生产环境应用，可以考虑配置一个自定义的、具有适当连接池和超时设置的URLSession实例，并通过OKHTTPSession协议注入。这能提升网络效率。

   let configuration = URLSessionConfiguration.default configuration.timeoutIntervalForRequest = 300 // 长生成任务的超时时间 configuration.httpMaximumConnectionsPerHost = 5 let customSession = URLSession(configuration: configuration) // OllamaKit 目前构造函数未直接暴露 session 注入，但你可以 fork 库或提 PR 来支持。

2. 上下文长度管理：大模型有上下文窗口限制（如 4096、8192 tokens）。你需要管理conversationHistory的总长度。一个简单的方法是计算每条消息的大致 token 数（一个粗略的估计是：英文字符数除以4，中文字符数乘以2），并在总长度接近限制时，移除最早的消息对（一个用户消息和一个助手消息）。更精确的做法是调用模型的 tokenizer 接口（如果 Ollama 提供）进行计算。

3. 错误恢复与重试：网络请求可能因各种原因失败。对于非关键操作（如获取模型列表），简单的错误提示即可。对于用户发送的消息，可以考虑加入重试逻辑。但要注意，对于已经部分流式响应的请求，重试需要更复杂的处理（可能需要清空已显示的部分内容并重新开始）。

4. 离线与缓存策略：如果你的应用有离线使用需求，可以考虑缓存一些常见的、生成结果稳定的对话（例如，对某些标准问题的回答）。虽然OllamaKit本身不提供缓存，但你可以在调用层实现，例如将(model, messages)的哈希值作为键，将完整的回复缓存到本地数据库或文件中。

5.3 进阶方向与生态结合

OllamaKit是一个优秀的客户端库，但它只是生态中的一环。结合 Swift 和 Apple 平台的其他技术，你可以构建出更强大的应用：

• 与 Core ML 结合：你可以使用 Ollama 处理复杂的语言理解和生成任务，而将一些轻量级、对延迟要求高的任务（如文本分类、情感分析）交给本地部署的 Core ML 模型。两者可以协同工作。
• 后台服务与菜单栏应用：利用 SwiftUI 和@main属性，你可以轻松创建菜单栏（Menu Bar）应用，让 Ollama 助手常驻在系统菜单栏，随时通过快捷键呼出。
• 支持 Function Calling：如果 Ollama 未来支持类似 OpenAI 的 Function Calling，OllamaKit可以扩展其模型来支持这一特性，让你的助手不仅能聊天，还能调用本地 API 执行操作（如查日历、发邮件）。
• 多模态扩展：Ollama 已经开始支持多模态模型（如 LLaVA）。OllamaKit的未来版本很可能会增加对图片上传和分析 API 的封装，届时你可以构建能“看图说话”的智能应用。

在我自己的使用中，OllamaKit最大的价值在于其“消除摩擦”的能力。它把一项基础设施级别的集成工作，变成了几句直观的 Swift 代码。这让我能更专注于思考“用 AI 做什么”，而不是“怎么连上 AI”。当然，它目前还是一个相对年轻的库，随着 Ollama 生态的快速发展，期待它持续迭代，成为 Swift 开发者探索本地大模型世界的首选工具。