\nPart 1: Introduction and Short Examples

We begin with a sufficient introduction for Swift to understand the programming examples. After introducing the language we will look at a few short examples that provide code and techniques we use later in the book:

Creating Swift projects
Writing command line utilities
Web scraping

",{"_361":362,"_42":43,"_46":47,"_44":45,"_64":65,"_363":364,"_439":359},"previewContent","

\n Cover Material, Copyright, and License\n
\n Preface\n
- \n Notes on the new June 2025 Book Edition\n
- \n Requests from the Author\n
- \n Notes on the Second Edition\n
- \n Book Structure\n
- \n Requests from the Author\n
- \n Parts of this Book are Specific for macOS and iOS, with Some Support for Linux\n
- \n Code for this Book\n
- \n Author’s Background\n
- \n Cover Art\n
- \n CoreML Libraries Used in this Book\n
- \n Swift 3rd Party Libraries\n
- \n Acknowledgements\n
\n
\n Part 1: Introduction and Short Examples\n
\n Setting Up Swift for Command Line Development\n
- \n Installing Swift Packages\n
- \n Creating Swift Packages\n
- \n Accessing Libraries that You Write in Other Projects\n
\n
\n Background Information for Writing Swift Command Line Utilities\n
- \n Using Shell Processes\n
- \n FileIO Examples\n
- \n Swift REPL\n
\n
\n Web Scraping\n
- \n Running in the Swift REPL\n
\n
\n Part 2: Large Language Models\n
\n Using the OpenAI LLM APIs\n
- \n Core Architecture\n
- \n Key Features\n
- \n Technical Implementation Details\n
- \n Running Tests\n
\n
\n Using APIs for Anthropic Claude LLMs\n
- \n Running the examples\n
\n
\n Using Groq APIs to Open Weight LLM Models\n
- \n Implementation of a Client Library for the Groq APIs\n
- \n Running the Tests\n
\n
\n Using the xAI Grok LLM\n
- \n Implementation of a Grok API Client Library\n
\n
\n Using Ollama to Run Local LLMs\n
- \n Running the Ollama Service\n
- \n Ollama Wrap Up\n
\n
\n Using Apple’s MLX Framework to Run Local LLMs\n
- \n MLX Framework History\n
- \n MLX Resources on GitHub\n
- \n Example Application for MLX Swift Examples Repository\n
- \n Analysis of Swift and SwiftUI Code in the LLMEval Application\n
\n
\n Part 3: Apple’s CoreML and NLP Libraries\n
\n Deep Learning Introduction\n
- \n Simple Multi-layer Perceptron Neural Networks\n
- \n Deep Learning\n
\n
\n Natural Language Processing Using Apple’s Natural Language Framework\n
- \n Using Apple’s NaturalLanguage Swift Library\n
- \n A simple Wrapper Library for Apple’s NLP Models\n
\n
\n Documents Question Answering Using OpenAI GPT4 APIs and a Local Embeddings Vector Database\n
- \n Extending the String Class\n
- \n Implementing a Local Vector Database for Document Embeddings\n
- \n Create Local Embeddings Vectors From Local Text Files With OpenAI GPT APIs\n
- \n Using Local Embeddings Vector Database With OpenAI GPT APIs\n
- \n Wrap Up for Using Local Embeddings Vector Database to Enhance the Use of GPT3 APIs With Local Documents\n
\n
\n Part 4: Knowledge Representation and Data Acquisition\n
\n Linked Data and the Semantic Web\n
- \n Understanding the Resource Description Framework (RDF)\n
- \n Frequently Used Resource Namespaces\n
- \n Understanding the SPARQL Query Language\n
- \n Semantic Web and Linked Data Wrap Up\n
\n
\n Example Application: iOS and macOS Versions of my KnowledgeBookNavigator\n
- \n Screen Shots of macOS Application\n
- \n Application Code Listings\n
\n
\n Part 5: Apple Intelligence\n
- \n Developers Can Now Weave Apple Intelligence Directly Into Their Apps\n
- \n Key Advantages for Developers:\n
\n
\n Using Apple Intelligence’s Default System Model To Build a Chat Command Line Tool\n
\n Using Apple Intelligence’s Default System Model To Build a Coding Assistant Command Line Tool\n
\n Book Wrap Up\n

\nCover Material, Copyright, and License

\n\n

This eBook will be updated occasionally so please periodically check the leanpub.com web page for this book for updates.

\n\n

The first edition was released spring of 2022.\nThe second edition was released December 2024.\nThe third edition was released June 2025.

\n\n

If you would like to support my work please consider purchasing my books on Leanpub and star my git repositories that you find useful on GitHub. You can also interact with me on social media on Mastodon and Twitter.

\n\n

\nPreface

\n\n

Why use Swift for hacking AI? Common Lisp has been my go-to language for artificial intelligence development and research since 1982. The transition to using Swift was a transition motivated by practical aspects of Swift and the Swift ecosystem.

\n\n

\nNotes on the new June 2025 Book Edition

\n\n

With the release of new Apple Intelligence tooling available for macOS26, iPadOS26, and iOS26 I have added a new Part 5 at the end of this book covering several practical AI use cases with new examples.

\n\n

\nRequests from the Author

\n\n

This book will always be available to read free online at https://leanpub.com/SwiftAI/read.

\n\n

That said, I appreciate it when readers purchase my books because the income enables me to spend more time writing.

\n\n

\nHire the Author as a Consultant

\n\n

I am available for short consulting projects. Please see https://markwatson.com.

\n\n

You can also interact with me on social media on Mastodon and Twitter.

\n\n

\nNotes on the Second Edition

\n\n

The second edition of this book deletes some of the old material and adds two new themes:

\n\n

A new Part II of the book that covers Large Language Models (LLMS). We will use both commercial LLM APIs and running local LLMs using Ollama and Apple’s MLX framework.
Several examples from the first edition are augmented using LLMs.
As much as possible, I support some of the book examples as Swift Playgrounds, usable on iPads and Macs.

\n\n

\nBook Structure

\n\n

This book starts out slowly in Part I with simple examples which I wrote showing how to access the Swift library packages on GitHub, tips on writing Swift command line apps.

\n\n

Part II will show you how to effectively integrate LLMs into your own applications.

\n\n

Part III starts with a simple example using web scraping and commercial web search APIs. We then work through examples integrating web search with LLMs and then show how we can modify web scraping applications to specifically process topics and have better control of outputing structured data.

\n\n

We then proceed to using Apple’s CoreML for Natural Language Processing (NLP), training and using your own CoreML models, using OpenAI’s GPT-4 APIs, and finally several semantic web/linked data examples. The book ends with the example macOS application Knowledge Graph Navigator. It is not my intention to cover in detail the use of SwiftUI for building iOS/iPadOS/macOS applications but I thought my readers might enjoy seeing several of the techniques covered in the book integrated into an example app.

\n\n

I have used Common Lisp for AI research projects and for AI product development and delivery since 1982. There is something special about using a language for almost forty years. I now find Swift a compelling choice for several reasons:

\n\n

Flexible language with many features I rely on like supporting closures and an interactive functional programming style.
Built-in support for deep learning neural network models for natural language processing, predictive models, etc.
First class support for iOS and macOS development.
Good support for server side applications hosted on Linux.

\n\n

Swift is a programmer-efficient language: code is concise and easy to read, and high quality libraries from Apple and third parties mean that often there is less code to write. I will share with you my Swift development work flow that combines interactive development of code in playgrounds, development of higher level libraries in text only or command line applications, and my general strategy for writing iOS and macOS applications after low level and intermediate code is written and debugged.

\n\n

\nRequests from the Author

\n\n

This book will always be available to read free online at https://leanpub.com/SwiftAI/read.

\n\n

That said, I appreciate it when readers purchase my books because the income enables me to spend more time writing.

\n\n

\nHire the Author as a Consultant

\n\n

I am available for short consulting projects. Please see https://markwatson.com.

\n\n

\nParts of this Book are Specific for macOS and iOS, with Some Support for Linux

\n\n

Swift is a general purpose language that is well supported in macOS, iOS, and Linux, with some support in Windows. Here, we cover the use of Swift on macOS and iOS. Some of the examples in this book rely on libraries that are specifically available on macOS and iOS like CoreML and the NLP libraries. Several book examples also work on Linux, such as the examples using SQLite, the Microsoft Azure search APIs, web scraping, and semantic web/linked data.

\n\n

\nCode for this Book

\n\n

Because of the way the Swift Package Manager works, I organized all book examples that build libraries as separate GitHub repos so the libraries can be easily used in other book examples as well as your own software projects. The separate library GitHub repositories are:

\n\n

\nhttps://github.com/mark-watson/SparqlQuery_swift - SPARQL Swift library for my Swift AI book.
\nhttps://github.com/mark-watson/QuestionAnswering_BERT_swift - modification of Apple’s question answering demo to use DBPedia.
\nhttps://github.com/mark-watson/swift-coreml-wisconsin_data_create_model - create CoreML models from training data files of Wisconsin Caner data.
\nhttps://github.com/mark-watson/swift-coreml-wisconsin_data_predict_with_model - use the pretrained Wisconsin Cancer data model.
\nhttps://github.com/mark-watson/ShellProcess_swift - library for spawning shell processes and capturing output to stdout.
\nhttps://github.com/mark-watson/WebScraping_swift - library for scrapping web sites.
\nhttps://github.com/mark-watson/OpenAI_swift - library for using OpenAI’s GPT3 APIs.
\nhttps://github.com/mark-watson/Nlp_swift - library that uses pretrained CoreML NLP models.
\nhttps://github.com/mark-watson/KGN - SwiftUI based application supporting macOS, iPadOS, and iOS. The macOS version is in Apple’s app store.

\n\n

I suggest cloning all of these GitHub repositories right now so you can have the example source code at hand while reading this book.

\n\n

All of the code examples are licensed using the Apache 2 license. You are free to reuse the book example code in your own projects (open source, commercial), with attribution of my copyright and the Apache 2 license.

\n\n

Except for the last SwiftUI example application, all sample programs are written as command line utilities. I considered using Swift playgrounds for some of the examples but decided that packaging as a combination of libraries and command line utilities would tend to make the example code more useful for your own projects.

\n\n

http://www.knowledgegraphnavigator.com/

\n\n

\nAuthor’s Background

\n\n

I have written 20+ books, mostly about artificial intelligence. I have over 50 US patents.

\n\n

I write about technologies that I have used throughout my career: knowledge representation using semantic web and linked data, machine learning and deep learning, and natural language processing. I am grateful for the companies where I have worked (SAIC, Google, Capital One, Olive AI, Babylist, etc.) that have supported this work since 1982.

\n\n

As an author, I hope that the material in this book entertains you and will be useful in your work.

\n\n

\nCover Art

\n\n

The cover picture was taken by WikiMedia Commons user Keta and is available for use under the Creative Commons License CC BY-SA 2.5.

\n\n

\nCoreML Libraries Used in this Book

\n\n

CoreML general overview: https://developer.apple.com/documentation/coreml
MLClassifier https://developer.apple.com/documentation/createml/mlclassifier
MLTextClassifier https://developer.apple.com/documentation/createml/mltextclassifier
NLModel https://developer.apple.com/documentation/naturallanguage/nlmodel
Natural Language Framework https://developer.apple.com/documentation/naturallanguage
MLCustomLayer https://developer.apple.com/documentation/coreml/mlcustomlayer

\n\n

\nSwift 3rd Party Libraries

\n\n

We use the following 3rd party libraries:

\n\n

https://github.com/SwiftyJSON/SwiftyJSON

\n\n

\nAcknowledgements

\n\n

I thank my wife Carol for editing this manuscript, finding typos, and suggesting improvements.

\n\n\n

\nPart 1: Introduction and Short Examples

\n\n

Creating Swift projects
Writing command line utilities
Web scraping

\n\n\n

\nSetting Up Swift for Command Line Development

\n\n

Except for the last chapter in this book that uses Xcode for developing a complete macOS/iOS/iPadOS example application, I assume that you will work through the book examples using the command line and your favorite editor. If you want to use Xcode for the command line examples, you can open the Swift package file on the command line and open Xcode using, for example:

\n\n

cd SparqlQuery_swift\nopen Package.swift\n

\n\n\n\n

You notice that most of the examples are command line apps or libraries with command line test programs and the README.md files in the example directories provide instructions for building and running on the command line.

\n\n

You can also run Xcode and from the File Menu open an example Package.swift file. You can then use the Product / Test menu to run the test code for the example. You might need to use the View / Debug Area / Active Console menu to show the output area.

\n\n

I assume that you are familiar with the Swift programming language and Xcode.

\n\n

Swift is a general purpose language that is well supported in macOS and iOS, with good support for Linux, and with some support in Windows. For the purposes of this book, we are only considering the use of Swift on macOS and iOS. Most of the examples in this book rely on libraries that are specifically available on macOS and iOS like CoreML and the NLP libraries.

\n\n

There are great free resources for the Swift language on the web, in other commercial books, and Apple’s free Swift books. Here I provide just enough material on the Swift language for you to understand and work with the book examples. After working through this book’s material you will be able to add machine learning, natural language processing, and knowledge representation to your applications. There will be parts of the Swift language that we don’t need for the material here, and we won’t cover.

\n\n

\nInstalling Swift Packages

\n\n

We will use the Swift Package Manager. You should pause reading now and install the Swift Package Manager if you have not already done so.

\n\n

I occasionally use https://vapor.codes web framework library (although not in this book). We use this 3rd party library as an example for building a library locally from source code. Start by cloning the git repository https://github.com/vapor/vapor. Then:

\n\n

git clone https://github.com/vapor/vapor.git\ncd vapor\nswift build\n

\n\n\n\n

I don’t usually install libraries locally from source code unless I am curious about the implementation and want to read through the source code. Later we will see how to reference Swift libraries hosted on GitHub in a project’s Package.swift file.

\n\n

\nCreating Swift Packages

\n\n

We will cover using the Swift Package Manager to create new packages using the command line here. Later we will create projects using Apple’s XCode IDE when we develop the example application Knowledge Graph Navigator.

\n\n

You will want to use the Swift Package Manager documentation for reference.

\n\n

We will be generating executable projects and library (with a sample main program) projects. The commands for generating the stub for an executable application project are:

\n\n

mkdir BingSearch\ncd BingSearch\nswift package init --type executable\n

\n\n\n\n

and build the stub of a library with a demo main program:

\n\n

mkdir SparqlQuery\ncd SparqlQuery\nswift package init --type library\n

\n\n\n\n

\nAccessing Libraries that You Write in Other Projects

\n\n

You can reference Swift libraries using the Swift.package file for each of your projects. We will look at parts of two Swift.package files here. The first is for my SPARQL query client library that we will develop in a later chapter. This library SparqlQuery_swift is used in both book examples Knowledge Graph Navigator (KGN) macOS/iOS/iPadOS example application as well as a text version KnowledgeGraphNavigator_swift.

\n\n

 1 import PackageDescription\n 2 \n 3 let package = Package(\n 4     name: \"SparqlQuery_swift\",\n 5     products: [\n 6         .library(\n 7             name: \"SparqlQuery_swift\",\n 8             targets: [\"SparqlQuery_swift\"]),\n 9     ],\n10     dependencies: [\n11       .package(url: \"https://github.com/SwiftyJSON/SwiftyJSON.git\",\n12           .branch(\"master\")),\n13    ],\n14     targets: [\n15         .target(\n16             name: \"SparqlQuery_swift\",\n17             dependencies: [\"SwiftyJSON\"]),\n18         .testTarget(\n19             name: \"SparqlQuery_swiftTests\",\n20             dependencies: [\"SparqlQuery_swift\", \"SwiftyJSON\"]),\n21     ]\n22 )\n

\n\n\n\n

This Swift package file is used to declare a Swift package named “SparqlQuery_swift”. The package contains one library target named “SparqlQuery_swift” and one test target named “SparqlQuery_swiftTests”. The library target depends on the “SwiftyJSON” package, which is specified as a dependency in the “dependencies” section of the package.

\n\n

The “products” section defines the products that this package provides. In this case, the package provides a library product named “SparqlQuery_swift”. The library is built from the source code in the “SparqlQuery_swift” target.

\n\n

The “dependencies” section lists the packages that this package depends on. In this case, it depends on the “SwiftyJSON” package, which is specified as a Git repository URL.

\n\n

The “targets” section lists the targets that are part of the package. In this case, there are two targets: “SparqlQuery_swift” and “SparqlQuery_swiftTests”. The “SparqlQuery_swift” target depends on “SwiftyJSON”. The “SparqlQuery_swiftTests” target depends on both “SparqlQuery_swift” and “SwiftyJSON”.

\n\n

The Swift.package file for text version KnowledgeGraphNavigator_swift is shown here:

\n\n

 1 import PackageDescription\n 2 \n 3 let package = Package(\n 4     name: \"KnowledgeGraphNavigator_swift\",\n 5     platforms: [\n 6         .macOS(.v10_15),\n 7     ],\n 8     dependencies: [\n 9         .package(url: \"https://github.com/SwiftyJSON/SwiftyJSON.git\",\n10             .branch(\"master\")),\n11         .package(url: \"https://github.com/scinfu/SwiftSoup.git\", from: \"1.7.4\"),\n12         .package(url: \"git@github.com:mark-watson/SparqlQuery_swift.git\",\n13             .branch(\"main\")),\n14         .package(url: \"git@github.com:mark-watson/Nlp_swift.git\", .branch(\"main\")),\n15     ],\n16     targets: [\n17         // Targets are the basic building blocks of a package.\n18         // A target can define a module or a test suite.\n19         // Targets can depend on other targets in this package,\n20         // and on products in packages this package depends on.\n21         .target(\n22             name: \"KnowledgeGraphNavigator_swift\",\n23             dependencies: [\"SparqlQuery_swift\", \"Nlp_swift\",\n24               \"SwiftyJSON\", \"SwiftSoup\"]),\n25     ]\n26 )\n

\n\n\n\n

This Swift package file is used to declare a Swift package named “KnowledgeGraphNavigator_swift”. The package contains one target named “KnowledgeGraphNavigator_swift”. The target depends on the “SparqlQuery_swift”, “Nlp_swift”, “SwiftyJSON”, and “SwiftSoup” packages, which are specified as dependencies in the “dependencies” section of the package.

\n\n

The “platforms” section specifies the minimum platform version that the package supports. In this case, the package supports macOS version 10.15 and later.

\n\n

The “dependencies” section lists the packages that this package depends on. In this case, it depends on four packages:

\n\n

SwiftyJSON: a Swift library for working with JSON data.
SwiftSoup: a Swift library for parsing HTML and XML documents.
SparqlQuery_swift: a Swift library for querying RDF data using the SPARQL query language.
Nlp_swift: a Swift library for natural language processing.

\n\n

The “targets” section lists the targets that are part of the package. In this case, there is one target named KnowledgeGraphNavigator_swift. The target depends on “SparqlQuery_swift, Nlp_swift, SwiftyJSON, and SwiftSoup.

\n\n

Hopefully you have cloned the git repositories for each book example and understand how I have configured the examples for your use.

\n\n

For the rest of this book, you can read chapters in any order. In some cases, earlier chapters will contain implementations of libraries used in later chapters.

\n\n\n

\nBackground Information for Writing Swift Command Line Utilities

\n\n

This short chapter contains example code and utilities for writing command line programs, using external shell processes, and using the FileIO library.

\n\n

\nUsing Shell Processes

\n\n

The library for using shell processes is one of my GitHub projects so you can include it in other projects using:

\n\n

1  dependencies: [\n2    .package(url: \"git@github.com:mark-watson/ShellProcess_swift.git\",\n3             .branch(\"main\")),\n4  ],\n

\n\n\n\n

You can clone this repository if you want to have the source code at hand:

\n\n

1 git clone https://github.com/mark-watson/ShellProcess_swift.git\n

\n\n\n\n

The following listing shows the library implementation. In line 5 we use the constructor Process from the Apple Foundation library to get a new process object that we set fields executableURL and argList. In lines 8 and 9 we create a new Unix style pipe to capture the output from the shell process we are starting and attach it to the process. After we run the task, we capture the output and return it as the value of function run_in_shell.

\n\n

 1 import Foundation\n 2 \n 3 @available(OSX 10.13, *)\n 4 public func run_in_shell(commandPath: String, argList: [String] = []) -> String {\n 5     let task = Process()\n 6     task.executableURL = URL(fileURLWithPath: commandPath)\n 7     task.arguments = argList\n 8     let pipe = Pipe()\n 9     task.standardOutput = pipe\n10     do {\n11         try! task.run()\n12         let data = pipe.fileHandleForReading.readDataToEndOfFile()\n13         let output: String? = String(data: data, encoding: String.Encoding.utf8)\n14         if let output = output {\n15           if !output.isEmpty {\n16             return output.trimmingCharacters(in: .whitespacesAndNewlines)\n17           }\n18         }\n19     }\n20     return \"\"\n21 }\n

\n\n\n\n

The function named run_in_shell takes two parameters: commandPath (a string representing the path to the executable command to be run) and argList (an array of strings representing the arguments to be passed to the command). The function returns a string that represents the output of the command.

\n\n

Function run_in_shell first creates an instance of the Process class, which is used to run the command. It sets the executableURL property of the task instance to the commandPath value and sets the arguments property to the argList value. This function then creates a Pipe instance, which is used to capture the output of the command. It sets the standardOutput property of the task instance to the Pipe instance.

\n\n

The function then runs the command using the run() method of the task instance. If the command runs successfully, the function reads the output of the command from the Pipe instance using the readDataToEndOfFile() method of the fileHandleForReading property. It then converts the output data to a string using the String(data:encoding:) initializer.

\n\n

If the output string is not empty, this function trims leading and trailing whitespace and returns the resulting string. Otherwise, the function returns an empty string.

\n\n

Overall, this function provides a simple way to run a shell command and capture its output in a Swift program.

\n\n

As in most examples in this book we use the Swift testing framework to run the example code at the command line using swift test. Running swift test does an implicit swift build.

\n\n

 1 import XCTest\n 2 @testable import ShellProcess_swift\n 3 \n 4 final class ShellProcessTests: XCTestCase {\n 5     func testExample() {\n 6         // This is an example of a functional test case.\n 7         // Use XCTAssert and related functions to verify your tests produce the\n 8         // correct results.\n 9         print(\"** s1:\")\n10         let s1 = run_in_shell(commandPath: \"/bin/ps\", argList: [\"a\"])\n11         print(s1)\n12         let s2 = run_in_shell(commandPath: \"/bin/ls\", argList: [\".\"])\n13         print(\"** s2:\")\n14         print(s2)\n15         let s3 = run_in_shell(commandPath: \"/bin/sleep\", argList: [\"2\"])\n16         print(\"** s3:\")\n17         print(s3)\n18 \n19     }\n20 \n21     static var allTests = [\n22         (\"testExample\", testExample),\n23     ]\n24 }\n

\n\n\n\n

This Swift unit test function is part of a test suite for the ShellProcess_swift package. The function is named testExample and is decorated with the @testable import statement to indicate that it tests an internal implementation detail of the ShellProcess_swift package.

\n\n

The function uses the run_in_shell function to run three shell commands: ps a, ls ., and sleep 2. It prints the output of each command to the console.

\n\n

This test function is an example of a functional test case. It doesn’t actually verify that the functions being tested produce the correct results. Instead, it’s a simple way to visually inspect the output of the commands and ensure that they are working as expected.

\n\n

The allTests variable is an array of tuples that map the test function names to the corresponding function references. This variable is used by the XCTest framework to discover and run the test functions.

\n\n

The test output (with some text removed for brevity) is:

\n\n

 1 $ swift test\n 2 Test Suite 'All tests' started at 2021-08-06 16:36:21.447\n 3 ** s1:\n 4 PID   TT  STAT      TIME COMMAND\n 5  3898 s000  Ss     0:00.01 login -pf markw8\n 6  3899 s000  S+     0:00.18 -zsh\n 7  3999 s001  Ss     0:00.02 login -pfl markw8 /bin/bash -c exec -la zsh /bin/zsh\n 8  4000 s001  S+     0:00.38 -zsh\n 9  5760 s002  Ss     0:00.02 login -pfl markw8 /bin/bash -c exec -la zsh /bin/zsh\n10  5761 s002  S      0:00.14 -zsh\n11  8654 s002  S+     0:00.06 /Applications/Xcode.app/Contents/Developer/Toolchains/Xco\\\n12 deDefault.xctoolchain/usr/bin/swift-test\n13  8665 s002  S      0:00.03 /Applications/Xcode.app/Contents/Developer/usr/bin/xctest\\\n14  /Users/markw_1/GIT_swift_book/ShellProcess_swift/.build/arm64-apple-macosx/debug/Sh\\\n15 ellProcess_swiftPackageTests.xctest\n16  8666 s002  R      0:00.00 /bin/ps a\n17 ** s2:\n18 Package.swift\n19 README.md\n20 Sources\n21 Tests\n22 ** s3:\n23 \n24 Test Suite 'All tests' passed at 2021-08-06 16:36:23.468.\n25 \t Executed 1 test, with 0 failures (0 unexpected) in 2.019 (2.021) seconds\n

\n\n\n\n

\nFileIO Examples

\n\n

This file I/O example uses the ShellProcess_swift library we saw in the last section so if you were to create your own Swift project with the following code listing, you would have to add this dependency in the Project.swift file.

\n\n

When writing command line Swift programs you will often need to do simple file IO so let’s look at some examples here:

\n\n

 1 import Foundation\n 2 import ShellProcess_swift // my library\n 3 \n 4 @available(OSX 10.13, *)\n 5 func test_files_demo() -> Void {\n 6     // In order to append to an existing file, you need to get a file handle\n 7     // and seek to the end of a file. The following will not work:\n 8     let s = \"the dog chased the cat\\n\"\n 9     try! s.write(toFile: \"out.txt\", atomically: true,\n10                  encoding: String.Encoding.ascii)\n11     let s2 = \"a second string\\n\"\n12     try! s2.write(toFile: \"out.txt\", atomically: true,\n13                   encoding: String.Encoding.ascii)\n14     let aString = try! String(contentsOfFile: \"out.txt\")\n15     print(aString)\n16 \n17     // For simple use cases, simply appending strings, then writing\n18     // the result atomically works fine:\n19     var s3 = \"the dog chased the cat\\n\"\n20     s3 += \"a second string\\n\"\n21     try! s3.write(toFile: \"out2.txt\", atomically: true,\n22                   encoding: String.Encoding.ascii)\n23     let aString2 = try! String(contentsOfFile: \"out2.txt\")\n24     print(aString2)\n25 \n26     // list files in current directory:\n27     let ls = run_in_shell(commandPath: \"/bin/ls\", argList: [\".\"])\n28     print(ls)\n29 \n30     // remove two temnporary files:\n31     let shellOutput = run_in_shell(commandPath: \"/bin/rm\",\n32                                    argList: [\"out.txt\", \"out2.txt\"])\n33     print(shellOutput)\n34 }\n35 \n36 if #available(OSX 10.13, *) {\n37     test_files_demo()\n38 }\n

\n\n\n\n

The OS version checks in this Swift code use the #available conditional compilation block.

\n\n

The #available block is used to conditionally compile code based on the availability of APIs or features in the operating system version. In this case, the code inside the #available(OSX 10.13, *) block will only be executed if the running operating system is macOS 10.13 or later.

\n\n

If the running operating system version is earlier than 10.13, the code inside the #available block will be skipped and the program will exit without running the test_files_demo() function.

\n\n

These operating system version checks are done to ensure that the program is only executed on operating systems that support the APIs and features used by the code. This helps to prevent runtime errors and crashes on older operating system versions that may not support the required features.

\n\n

This function demonstrates how to write to and read from files using the write(toFile:atomically:encoding:) and String(contentsOfFile:) methods, how to list files in the current directory using the ls shell command, and how to remove files using the rm shell command.

\n\n

I created a temporary Swift project with the previous code listing and a Project.swift file. I built and ran this example using the swift command line tool.

\n\n

Unlike the example in the last section where we built a reusable library with a test program, here we have a standalone program contained in a single file so we will use swift run to build and run this example:

\n\n

 1 $ swift run\n 2 Fetching git@github.com:mark-watson/ShellProcess_swift.git from cache\n 3 Cloning git@github.com:mark-watson/ShellProcess_swift.git\n 4 Resolving git@github.com:mark-watson/ShellProcess_swift.git at main\n 5 [5/5] Build complete!\n 6 a second string\n 7 \n 8 the dog chased the cat\n 9 a second string\n10 \n11 Package.resolved\n12 Package.swift\n13 README.md\n14 Sources\n15 out.txt\n16 out2.txt\n

\n\n\n\n

\nSwift REPL

\n\n

There is an example of using the Swift REPL at the end of the next chapter on web scraping. For reference, you can start a REPL with:

\n\n

1 $ swift run --repl\n2 Type :help for assistance.\n3 1> import WebScraping_swift\n4 2> webPageText(uri: \"https://markwatson.com\")\n5 $R0: String = \"Mark Watson: AI Practitioner and Polyglot Programmer\"...\n6 3> public func foo(s: String) -> String { return s } \n7 4> foo(s: \"cat\") \n8 $R1: String = \"cat\"\n9 5> \n

\n\n\n\n

You can import packages and interactively enter Swift expressions, including defining functions.

\n\n

In the next chapter we will look at a longer example that scrapes web sites.

\n\n

In the next chapter we will look at one more simple example, building a web scraping library, before getting to the machine learning and NLP part of the book.

\n\n\n

\nWeb Scraping

\n\n

It is important to respect the property rights of web site owners and abide by their terms and conditions for use. This Wikipedia article on Fair Use provides a good overview of using copyright material.

\n\n

The web scraping code we develop here uses the Swift library SwiftSoup that is loosely based on the BeautifulSoup libraries available in other programming languages.

\n\n

For my work and research, I have been most interested in using web scraping to collect text data for natural language processing but other common applications include writing AI news collection and summarization assistants, trying to predict stock prices based on comments in social media which is what we did at Webmind Corporation in 2000 and 2001, etc.

\n\n

I wrote a simple web scraping library that is available at https://github.com/mark-watson/WebScraping_swift that you can use in your projects by putting the following dependency in your Project.swift file:

\n\n

1     dependencies: [\n2          .package(url: \"git@github.com:mark-watson/WebScraping_swift.git\",\n3              .branch(\"main\")),\n4     ],\n

\n\n\n\n

Here is the main implementation file for the library:

\n\n

 1 import Foundation\n 2 import SwiftSoup\n 3 \n 4 public func webPageText(uri: String) -> String {\n 5     guard let myURL = URL(string: uri) else {\n 6         print(\"Error: \\(uri) doesn't seem to be a valid URL\")\n 7         fatalError(\"invalid URI\")\n 8     }\n 9     let html = try! String(contentsOf: myURL, encoding: .ascii)\n10     let doc: Document = try! SwiftSoup.parse(html)\n11     let plain_text = try! doc.text()\n12     return plain_text\n13 }\n14 \n15 func webPageHeadersHelper(uri: String, headerName: String) -> [String] {\n16     var ret: [String] = []\n17     guard let myURL = URL(string: uri) else {\n18         print(\"Error: \\(uri) doesn't seem to be a valid URL\")\n19         fatalError(\"invalid URI\")\n20     }\n21     do {\n22         let html = try String(contentsOf: myURL, encoding: .ascii)\n23         let doc: Document = try SwiftSoup.parse(html)\n24         let h1_headers = try doc.select(headerName)\n25         for el in h1_headers {\n26             let h1 = try el.text()\n27             ret.append(h1)\n28         }\n29     } catch {\n30         print(\"Error\")\n31     }\n32     return ret\n33 }\n34 \n35 public func webPageH1Headers(uri: String) -> [String] {\n36     return webPageHeadersHelper(uri: uri, headerName: \"h1\")\n37 }\n38     \n39 public func webPageH2Headers(uri: String) -> [String] {\n40     return webPageHeadersHelper(uri: uri, headerName: \"h2\")\n41 }\n42 \n43 public func webPageAnchors(uri: String) -> [[String]] {\n44     var ret: [[String]] = []\n45     guard let myURL = URL(string: uri) else {\n46         print(\"Error: \\(uri) doesn't seem to be a valid URL\")\n47         fatalError(\"invalid URI\")\n48     }\n49     do {\n50         let html = try String(contentsOf: myURL, encoding: .ascii)\n51         let doc: Document = try SwiftSoup.parse(html)\n52         let anchors = try doc.select(\"a\")\n53         for a in anchors {\n54             let text = try a.text()\n55             let a_uri = try a.attr(\"href\")\n56             if a_uri.hasPrefix(\"#\") {\n57                 ret.append([text, uri + a_uri])\n58             } else {\n59                 ret.append([text, a_uri])\n60             }\n61         }\n62     } catch {\n63         print(\"Error\")\n64     }\n65     return ret\n66 }\n

\n\n\n\n

This Swift code defines several functions that can be used to scrape information from a web page located at a given URI.

\n\n

The webPageText function takes a URI as input and returns the plain text content of the web page located at that URI. It first checks if the URI is valid and then reads the content of the web page using the contentsOf method of the String class. It then uses the parse method of the SwiftSoup library to parse the HTML content of the page and extract the plain text.

\n\n

The webPageH1Headers and webPageH2Headers functions use the webPageHeadersHelper function to extract the H1 and H2 header texts respectively from the web page located at a given URI. The webPageHeadersHelper function uses the same technique as the webPageText function to read and parse the HTML content of the page. It then selects the headers using the specified headerName parameter and extracts the text of the headers.

\n\n

The webPageAnchors function extracts all the anchor tags <a> from the web page located at a given URI, along with their corresponding text and URI. It also uses the webPageHeadersHelper function to read and parse the HTML content of the page, selects the anchor tags using the “a” selector, and extracts their text and href attributes.

\n\n

Overall, these functions provide a simple way to scrape information from a web page and extract specific information such as plain text, header texts, and anchor tags.

\n\n

I wrote these utility functions to get the plain text from a web site, HTML header text, and anchors. You can clone this library and extend it for other types of HTML elements you may need to process.

\n\n

The test program shows how to call the APIs in the library:

\n\n

 1 import XCTest\n 2 import Foundation\n 3 import SwiftSoup\n 4 \n 5 @testable import WebScraping_swift\n 6 \n 7 final class WebScrapingTests: XCTestCase {\n 8     func testGetWebPage() {\n 9         let text = webPageText(uri: \"https://markwatson.com\")\n10         print(\"\\n\\n\\tTEXT FROM MARK's WEB SITE:\\n\\n\", text)\n11     }\n12 \n13     func testToShowSwiftSoupExamples() {\n14         let myURLString = \"https://markwatson.com\"\n15         let h1_headers = webPageH1Headers(uri: myURLString)\n16         print(\"\\n\\n++ h1_headers:\", h1_headers)\n17         let h2_headers = webPageH2Headers(uri: myURLString)\n18         print(\"\\n\\n++ h2_headers:\", h2_headers)\n19         let anchors = webPageAnchors(uri: myURLString)\n20         print(\"\\n\\n++ anchors:\", anchors)\n21 }\n22 \n23     static var allTests = [(\"testGetWebPage\", testGetWebPage),\n24                            (\"testToShowSwiftSoupExamples\",\n25                             testToShowSwiftSoupExamples)]\n26 }\n

\n\n\n\n

This Swift test program tests the functionality of the WebScraping_swift library. It defines two test functions: testGetWebPage and testToShowSwiftSoupExamples.

\n\n

The testGetWebPage function uses the webPageText function to retrieve the plain text content of my website located at “https://markwatson.com”. It then prints the retrieved text to the console.

\n\n

The testToShowSwiftSoupExamples function demonstrates the use of webPageH1Headers, webPageH2Headers, and webPageAnchors functions on the same website. It extracts and prints the H1 and H2 header texts and anchor tags of the same website.

\n\n

Overall, this Swift test program demonstrates how to use the functions defined in the WebScraping_swift library to extract specific information from a web page.

\n\n

Here we run the unit tests (with much of the output not shown for brevity):

\n\n

 1 $ swift test\n 2 \n 3 \tTEXT FROM MARK's WEB SITE:\n 4 \n 5  Mark Watson: AI Practitioner and Polyglot Programmer | Mark Watson    Read my Blog \\\n 6    Fun stuff    My Books    My Open Source Projects    Hire Me    Free Mentoring    \\\n 7 Privacy Policy Mark Watson: AI Practitioner and Polyglot Programmer I am the author \\\n 8 of 20+ books on Artificial Intelligence, Common Lisp, Deep Learning, Haskell, Clojur\\\n 9 e, Java, Ruby, Hy language, and the Semantic Web. I have 55 US Patents. My customer \\\n10 list includes: Google, Capital One, Olive AI, CompassLabs, Disney, SAIC, Americast, \\\n11 PacBell, CastTV, Lutris Technology, Arctan Group, Sitescout.com, Embed.ly, and Webmi\\\n12 nd Corporation.\n13 \n14 ++ h1_headers: [\"Mark Watson: AI Practitioner and Polyglot Programmer\", \"The books t\\\n15 hat I have written\", \"Fun stuff\", \"Open Source\", \"Hire Me\", \"Free Mentoring\", \"Priva\\\n16 cy Policy\"]\n17 \n18 ++ h2_headers: [\"I am the author of 20+ books on Artificial Intelligence, Common Lis\\\n19 p, Deep Learning, Haskell, Clojure, Java, Ruby, Hy language, and the Semantic Web. I\\\n20  have 55 US Patents.\", \"Other published books:\"]\n21 \n22 ++ anchors: [[\"Read my Blog\", \"https://mark-watson.blogspot.com\"], [\"Fun stuff\", \"ht\\\n23 tps://markwatson.com#fun\"], [\"My Books\", \"https://markwatson.com#books\"], [\"My Open \\\n24 Source Projects\", \"https://markwatson.com#opensource\"], [\"Hire Me\", \"https://markwat\\\n25 son.com#consulting\"], [\"Free Mentoring\", \"https://markwatson.com#mentoring\"], [\"Priv\\\n26 acy Policy\", \"https://markwatson.com/privacy.html\"], [\"leanpub\", \"https://leanpub.co\\\n27 m/u/markwatson\"], [\"GitHub\", \"https://github.com/mark-watson\"], [\"LinkedIn\", \"https:\\\n28 //www.linkedin.com/in/marklwatson/\"], [\"Twitter\", \"https://twitter.com/mark_l_watson\\\n29 \"], [\"leanpub\", \"https://leanpub.com/lovinglisp\"], [\"leanpub\", \"https://leanpub.com/\\\n30 haskell-cookbook/\"], [\"leanpub\", \"https://leanpub.com/javaai\"], \n31 ]\n32 Test Suite 'All tests' passed at 2021-08-06 17:37:11.062.\n33 \t Executed 2 tests, with 0 failures (0 unexpected) in 0.471 (0.472) seconds\n

\n\n\n\n

\nRunning in the Swift REPL

\n\n

 1 $ swift run --repl\n 2 [1/1] Build complete!\n 3 Launching Swift REPL with arguments: -I/Users/markw_1/GIT_swift_book/WebScraping_swi\\\n 4 ft/.build/arm64-apple-macosx/debug -L/Users/markw_1/GIT_swift_book/WebScraping_swift\\\n 5 /.build/arm64-apple-macosx/debug -lWebScraping_swift__REPL\n 6 Welcome to Apple Swift version 5.5 (swiftlang-1300.0.29.102 clang-1300.0.28.1).\n 7 Type :help for assistance.\n 8   1> import WebScraping_swift\n 9   2> webPageText(uri: \"https://markwatson.com\")\n10 $R0: String = \"Mark Watson: AI Practitioner and Polyglot Programmer | Mark Watson   \\\n11  Read my Blog    Fun stuff    My Books    My Open Source Projects    Privacy Policy \\\n12 Mark Watson: AI Practitioner and Polyglot Programmer I am the author of 20+ books on\\\n13  Artificial Intelligence, Common Lisp, Deep Learning, Haskell, Clojure, Java, Ruby, \\\n14 Hy language, and the Semantic Web. I have 55 US Patents. My customer list includes: \\\n15 Google, Capital One, Babylist, Olive AI, CompassLabs, Disney, SAIC, Americast, PacBe\\\n16 ll, CastTV, Lutris Technology, Arctan Group, Sitescout.com, Embed.ly, and Webmind Co\\\n17 rporation\"...\n18   3>  \n

\n\n\n\n

This chapter finishes a quick introduction to using Swift and Swift packages for command line utilities. The remainder of this book comprises machine learning, natural language processing, and semantic web/linked data examples.

\n\n\n

\nPart 2: Large Language Models

\n\n

In this part we cover:

\n\n

Commercial OpenAI LLM APIs
Commercial Anthropic LLM APIs
Accessing open weight models using the commercial Groq service
Accesiing xAIs Grok model via an API
Accessing local LLMs using Ollama
Using Local LLMs with Apple’s MLX Framework

\n\n\n

\nUsing the OpenAI LLM APIs

\n\n

I have been working as an artificial intelligence practitioner since 1982 and the capability of Large Language Models (LLMs) is unlike anything I have seen before. I managed a deep learning team at Capital One in 2017-2019 and we used precursors of TransFormer models like OpenAI’s ChatGPT, and Anthropic’s Claude.

\n\n

You will need to apply to OpenAI for an access key at:

\n\n

https://platform.openai.com/signup\n

\n\n\n\n

The GitHub repository for this example is:

\n\n

https://github.com/mark-watson/OpenAI_swift\n

\n\n\n\n

I recommend reading the online documentation for the online documentation for the APIs to see all the capabilities of the beta OpenAI APIs. Let’s start by jumping into the example code that is a GitHub repository https://github.com/mark-watson/OpenAI_swift that you can use in your projects.

\n\n

The library that I wrote for this chapter supports four functions: for completing text, summarizing text, answering general questions, and getting embeddings for text. The get-4o-mini that we will use here is very inexpensive and capable.

\n\n

You need to request an API key (I had to wait a few weeks to receive my key) and set the value of the environment variable OPENAI_KEY to your key. You can add a statement like:

\n\n

export OPENAI_KEY=sa-hdedds7&dhdhsdffd...\n

\n\n\n\n

to your .profile or other shell resource file that contains your key value (the above key value is made-up and invalid).

\n\n

The file Sources/OpenAI_swift/OpenAI_swift.swift contains the source code (code description follows the listing):

\n\n

import Foundation\n\nstruct OpenAI {\n    private static let key = ProcessInfo.processInfo.environment[\"OPENAI_KEY\"]!\n    private static let baseURL = \"https://api.openai.com/v1\"\n    \n    private struct ChatRequest: Encodable {\n        let model: String\n        let messages: [[String: String]]\n        let max_tokens: Int\n        let temperature: Double\n    }\n    \n    private struct EmbeddingRequest: Encodable {\n        let model: String\n        let input: String\n    }\n    \n    private static func makeRequest<T: Encodable>(endpoint: String, body: T)\n                            -> String {\n        var responseString = \"\"\n        let url = URL(string: baseURL + endpoint)!\n        var request = URLRequest(url: url)\n        request.httpMethod = \"POST\"\n        request.setValue(\"application/json\", forHTTPHeaderField: \"Content-Type\")\n        request.setValue(\"Bearer \\(key)\", forHTTPHeaderField: \"Authorization\")\n        request.httpBody = try? JSONEncoder().encode(body)\n        \n        let semaphore = DispatchSemaphore(value: 0)\n        URLSession.shared.dataTask(with: request) { data, response, error in\n            if let error = error {\n                print(\"Error: \\(error)\")\n            }\n            if let data = data {\n                responseString = String(data: data, encoding: .utf8) ?? \"{}\"\n            }\n            semaphore.signal()\n        }.resume()\n        semaphore.wait()\n        \n        return responseString\n    }\n    \n    static func chat(messages: [[String: String]], maxTokens: Int = 25,\n                                temperature: Double = 0.3) -> String {\n        let chatRequest = ChatRequest(\n            model: \"gpt-4o-mini\",\n            messages: messages,\n            max_tokens: maxTokens,\n            temperature: temperature\n        )\n        \n        let response = makeRequest(endpoint: \"/chat/completions\", body: chatRequest)\n        guard let data = response.data(using: .utf8),\n              let json = try? JSONSerialization.jsonObject(with: data)\n                         as? [String: Any],\n              let choices = json[\"choices\"] as? [[String: Any]],\n              let firstChoice = choices.first,\n              let message = firstChoice[\"message\"] as? [String: Any],\n              let content = message[\"content\"] as? String else {\n            return \"\"\n        }\n        return content\n    }\n    \n    static func embeddings(text: String) -> [Float] {\n        let embeddingRequest = EmbeddingRequest(\n            model: \"text-embedding-ada-002\",\n            input: text\n        )\n        \n        let response = makeRequest(endpoint: \"/embeddings\", body: embeddingRequest)\n        guard let data = response.data(using: .utf8),\n              let json = try? JSONSerialization.jsonObject(with: data)\n                         as? [String: Any],\n              let dataArray = json[\"data\"] as? [[String: Any]],\n              let embedding = dataArray.first?[\"embedding\"] as? [NSNumber] else {\n            return [1.23]\n        }\n        return embedding.map { number in Float(truncating: number) }\n    }\n}\n\n// Usage functions:\nfunc summarize(text: String, maxTokens: Int = 40) -> String {\n    OpenAI.chat(messages: [\n        [\"role\": \"system\",\n         \"content\":\n           \"You are a helpful assistant that summarizes text concisely.\"],\n        [\"role\": \"user\", \"content\": text]\n    ], maxTokens: maxTokens)\n}\n\nfunc questionAnswering(question: String) -> String {\n    OpenAI.chat(messages: [\n        [\"role\": \"system\",\n         \"content\":\n           \"You are a helpful assistant that answers questions directly and concisel\\\ny.\"],\n        [\"role\": \"user\", \"content\": question]\n    ], maxTokens: 25)\n}\n\nfunc completions(promptText: String, maxTokens: Int = 25) -> String {\n    OpenAI.chat(messages: [[\"role\": \"user\", \"content\": promptText]],\n                           maxTokens: maxTokens)\n}\n

\n\n\n\n

This Swift implementation provides a streamlined interface to OpenAI’s API services, focusing primarily on chat completions and text embeddings functionality. The code is structured around a central OpenAI struct that encapsulates all API interactions and provides a clean, type-safe interface for making requests.

\n\n

\nCore Architecture

\n\n

The implementation follows a modular design pattern, separating concerns between network communication, request/response handling, and utility functions. It utilizes Swift’s strong type system through dedicated request models and leverages environment variables for secure API key management.

\n\n

\nKey Features

\n\n

\nAuthentication and Configuration

\n\n

The client automatically retrieves the OpenAI API key from environment variables, providing a secure way to handle authentication credentials. The base URL is configured as a constant, making it easy to modify for different environments or API versions.

\n\n

\nChat Completions

\n\n

The chat completion functionality supports the GPT-4 model family, allowing for structured conversations through an array of messages. Each message contains a role (system, user, or assistant) and content. The implementation provides fine-grained control over:

\n\n

Maximum token output
Temperature settings for response randomness
Message context management
Text embeddings

\n\n

The embeddings feature implements OpenAI’s text-embedding-ada-002 model, converting text inputs into high-dimensional vector representations. These embeddings can be used for:

\n\n

Semantic search
Text similarity comparisons
Document classification
Other natural language processing tasks

\n\n

\nUtility Functions

\n\n

The implementation includes pre-built utility functions for common use cases:

\n\n

Text summarization with customizable length
Question-answering with concise responses
General text completions

\n\n

\nTechnical Implementation Details

\n\n

\nNetwork Communication

\n\n

The networking layer uses URLSession with a synchronous approach via DispatchSemaphore. While this ensures straightforward usage, it’s worth noting that this approach should be carefully considered for production environments where asynchronous communication might be more appropriate.

\n\n

\nError Handling

\n\n

The implementation includes basic error handling through Swift’s optional binding and guard statements, providing graceful fallbacks for common failure scenarios. The embedding function, for instance, returns a default value rather than throwing an error when processing fails.

\n\n

\nData Parsing

\n\n

JSON parsing is handled through a combination of JSONEncoder for requests and JSONSerialization for responses, with careful optional chaining to safely handle malformed or unexpected responses.

\n\n

\nRunning Tests

\n\n

The file SWIFT_BOOK/OpenAI_swift/Tests/OpenAI_swiftTests/OpenAI_swiftTests.swift contains test code:

\n\n

 1     import XCTest\n 2     @testable import OpenAI_swift\n 3 \n 4     final class OpenAI_swiftTests: XCTestCase {\n 5         func testExample() {\n 6             print(\"Starting tests...\")\n 7             let embeds = OpenAI.embeddings(text: \"Congress passed tax laws.\")\n 8             print(embeds[..<min(10, embeds.count)])\n 9             let prompt = \"He walked to the river and looked at\"\n10             let ret = completions(promptText: prompt)\n11             print(\"** ret from OpenAI API call:\", ret)\n12             let question = \"Where was Leonardo da Vinci born?\"\n13             let answer = questionAnswering(question: question)\n14             print(\"** answer from OpenAI API call:\", answer)\n15             let text = \"Jupiter is the fifth planet from the Sun and the largest in \\\n16 the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but \\\n17 two-and-a-half times that of all the other planets in the Solar System combined. Jup\\\n18 iter is one of the brightest objects visible to the naked eye in the night sky, and \\\n19 has been known to ancient civilizations since before recorded history. It is named a\\\n20 fter the Roman god Jupiter.[19] When viewed from Earth, Jupiter can be bright enough\\\n21  for its reflected light to cast visible shadows,[20] and is on average the third-br\\\n22 ightest natural object in the night sky after the Moon and Venus.\"\n23             let summary = summarize(text: text)\n24             print(\"** generated summary: \", summary)\n25         }\n26     }\n

\n\n\n\n

Output from this test code is:

\n\n

$ swift test\nBuilding for debugging...\n[4/4] Compiling OpenAI_swift OpenAI_swift.swift\nBuild complete! (0.59s)\nTest Suite 'All tests' started at 2024-11-17 16:42:12.354.\nTest Suite 'OpenAI_swiftPackageTests.xctest' started at 2024-11-17 16:42:12.355.\nTest Suite 'OpenAI_swiftTests' started at 2024-11-17 16:42:12.355.\nTest Case '-[OpenAI_swiftTests.OpenAI_swiftTests testExample]' started.\nTest Case '-[OpenAI_swiftTests.OpenAI_swiftTests testExample]' passed (7.429 seconds\\\n).\nTest Suite 'OpenAI_swiftTests' passed at 2024-11-17 16:42:19.784.\n\t Executed 1 test, with 0 failures (0 unexpected) in 7.429 (7.429) seconds\nTest Suite 'OpenAI_swiftPackageTests.xctest' passed at 2024-11-17 16:42:19.785.\n\t Executed 1 test, with 0 failures (0 unexpected) in 7.429 (7.430) seconds\nTest Suite 'All tests' passed at 2024-11-17 16:42:19.785.\n\t Executed 1 test, with 0 failures (0 unexpected) in 7.429 (7.431) seconds\nStarting tests...\n[-0.0046315026, -0.0077434415, 0.0005571732, -0.024781546, -0.0031119392, -0.0185893\\\n25, -0.003362034, -0.020906659, 0.0074585234, -0.019463073]\n** ret from OpenAI API call: the shimmering surface of the water, where the sunlight\\\n danced in tiny sparkles. The gentle flow of the river whispered secrets as\n** answer from OpenAI API call: Leonardo da Vinci was born in Vinci, Italy, on April\\\n 15, 1452.\n** generated summary:  Jupiter is the fifth planet from the Sun and the largest in t\\\nhe Solar System, being a gas giant with a mass one-thousandth that of the Sun and tw\\\no-and-a-half times that of\n* Test run started.\n* Testing Library Version: 102 (arm64e-apple-macos13.0)\n* Test run with 0 tests passed after 0.001 seconds.\n

\n\n\n\n\n

\nUsing APIs for Anthropic Claude LLMs

\n\n

Here, I decided to not write a new client library for the Anthropic APIs since there are several existing high quality libraries for accessing the Anthropic Claude APIs.

\n\n

This is not a strong recommendation of one Anthropic client library over another, but I very much enjoy using the following project because of the simplicity of its API:

\n\n

https://github.com/fumito-ito/AnthropicSwiftSDK\n

\n\n\n\n

My examples using this library to access the Anthropic Claude APIs can be found here:

\n\n

https://github.com/mark-watson/Anthropic_swift_examples\n

\n\n\n\n

You need to set the following environment variable for your person Anthropic API key: Anthropic API key:

\n\n

ANTHROPIC_API_KEY\n

\n\n\n\n

that you can get by creating an account:

\n\n

https://console.anthropic.com\n

\n\n\n\n

Note that there is no library implemented in this chapter.

\n\n

\nRunning the examples

\n\n

All of the examples are packaged as Swift tests so git clone my examples repository https://github.com/mark-watson/Anthropic_swift_examples and run:

\n\n

swift test\n

\n\n\n\n

The test Swift source file defines a test class (just the first few lines shown here):

\n\n

final class Anthropic_swift_examplesTests: XCTestCase {\n  let text1 = \"If Mary is 42, Bill is 27, and Sam is 51, what are their pairwise age\\\n differences. Please be concise.\"\n  func testExample() async throws {\n    let key = \n      ProcessInfo.processInfo.environment[\"ANTHROPIC_API_KEY\"]!\n    let anthropic = Anthropic(apiKey: key)\n    let message = Message(role: .user,\n                          content: [.text(text1)])\n    let response =\n      try await\n        anthropic.messages.createMessage([message],\n                                         maxTokens: 400)\n

\n\n\n\n

If you print the value of response you see:

\n\n

MessagesResponse(id: \"msg_02RvimFjHFFmaV4n994J9wck\", type: AnthropicSwiftSDK.Message\\\nsResponseType.message, role: AnthropicSwiftSDK.Role.assistant, content: [AnthropicSw\\\niftSDK.Content.text(\"The pairwise age differences are:\\n\\nMary and Bill: 15 years\\nM\\\nary and Sam: 9 years\\nBill and Sam: 24 years\", cacheControl: nil)], model: Optional(\\\nAnthropicSwiftSDK.Model.claude_3_Opus), stopReason: Optional(AnthropicSwiftSDK.StopR\\\neason.endTurn), stopSequence: nil, usage: AnthropicSwiftSDK.TokenUsage(inputTokens: \\\nOptional(38), outputTokens: Optional(38)))\n

\n\n\n\n

If you print the value of response.content you see:

\n\n

[AnthropicSwiftSDK.Content.text(\"The pairwise age differences are:\\n\\nMary and Bill:\\\n 15 years\\nMary and Sam: 9 years\\nBill and Sam: 24 years\", cacheControl: nil)]\n

\n\n\n\n

For normal use you want just the string contents of the model’s response to your prompt, so use:

\n\n

  for content in response.content {\n    if case let .text(text, _) = content {\n        print(\"Assistant's response: \\(text)\")\n    }\n  }\n

\n\n\n\n

That outputs:

\n\n

Assistant's response: The pairwise age differences are:\n\nMary and Bill: 15 years\nMary and Sam: 9 years\nBill and Sam: 24 years\n

\n\n\n\n

In the general case of the Claude model returning images, tools used, and tool results, use code like this:

\n\n

  for content in response.content {\n     switch content {\n       case .text(let text, _):\n         print(\"Assistant's response: \\(text)\")\n       case .image(let imageContent, _):\n         print(\"imageContent: \\(imageContent)\")\n         break\n       case .document(let documentContent, _):\n         print(\"documentContent: \\(documentContent)\")\n         break\n       case .toolResult(let toolResult):\n         print(\"toolResult: \\(toolResult)\")\n         break\n       case .toolUse(let toolUse):\n         print(\"toolUse: \\(toolUse)\")\n         break\n       }\n     }\n  }\n

\n\n\n\n\n

\nUsing Groq APIs to Open Weight LLM Models

\n\n

Groq develops custom silicon for fast LLM inference.

\n\n

Groq’s API service supports a variety of openly available models, including:

\n\n

Llama 3.1 Series: Models like llama-3.1-70b-versatile, llama-3.1-8b-instant, and others, offering up to 128K context windows.
Llama 3.2 Vision Series: Multimodal models such as llama-3.2-90b-vision-preview and llama-3.2-11b-vision-preview, capable of processing both text and image inputs.
Llama 3 Groq Tool Use Models: Specialized for function calling, including llama3-Groq-70b-8192-tool-use-preview and llama3-Groq-8b-8192-tool-use-preview.
Mixtral 8x7b: A model with a 32,768-token context window, suitable for extensive context applications.
Gemma Series: Models like gemma2-9b-it and gemma-7b-it, each with an 8,192-token context window.
Whisper Series: Models such as whisper-large-v3 and whisper-large-v3-turbo, designed for audio transcription and translation tasks.

\n\n

To obtain an API key, visit Groq’s API keys management page:

\n\n

https://console.groq.com/keys\n

\n\n\n\n

The code for this chapter can be found here:

\n\n

https://github.com/mark-watson/Groq_swift\n

\n\n\n\n

\nImplementation of a Client Library for the Groq APIs

\n\n

Groq supports the OpenAI APIs so the following client library for Groq is similar to what I wrote previously for OpenAI:

\n\n

import Foundation\n\nstruct Groq {\n    private static let key = ProcessInfo.processInfo.environment[\"GROQ_API_KEY\"]!\n    private static let baseURL = \"https://api.groq.com/openai/v1/\"\n    \n    private static let MODEL = \"llama3-8b-8192\"\n\n    private struct ChatRequest: Encodable {\n        let model: String\n        let messages: [[String: String]]\n        let max_tokens: Int\n        let temperature: Double\n    }\n    \n    private static func makeRequest<T: Encodable>(endpoint: String, body: T)\n                        -> String {\n        var responseString = \"\"\n        let url = URL(string: baseURL + endpoint)!\n        var request = URLRequest(url: url)\n        request.httpMethod = \"POST\"\n        request.setValue(\"application/json\", forHTTPHeaderField: \"Content-Type\")\n        request.setValue(\"Bearer \\(key)\", forHTTPHeaderField: \"Authorization\")\n        request.httpBody = try? JSONEncoder().encode(body)\n        \n        let semaphore = DispatchSemaphore(value: 0)\n        URLSession.shared.dataTask(with: request) { data, response, error in\n            if let error = error {\n                print(\"Error: \\(error)\")\n            }\n            if let data = data {\n                responseString = String(data: data, encoding: .utf8) ?? \"{}\"\n            }\n            semaphore.signal()\n        }.resume()\n        semaphore.wait()\n\n        return responseString\n    }\n    \n    static func chat(messages: [[String: String]],\n                                maxTokens: Int = 25,\n                                temperature: Double = 0.3)\n                                                 -> String {\n        let chatRequest = ChatRequest(\n            model: MODEL,\n            messages: messages,\n            max_tokens: maxTokens,\n            temperature: temperature\n        )\n        \n        let response = makeRequest(endpoint: \"/chat/completions\", body: chatRequest)\n        guard let data = response.data(using: .utf8),\n              let json = try? JSONSerialization.jsonObject(with: data)\n                         as? [String: Any],\n              let choices = json[\"choices\"] as? [[String: Any]],\n              let firstChoice = choices.first,\n              let message = firstChoice[\"message\"]\n                                     as? [String: Any],\n              let content = message[\"content\"] as? String else {\n            return \"\"\n        }\n        return content\n    }\n\n}\n\n// Usage functions:\nfunc summarize(text: String, maxTokens: Int = 40) -> String {\n    Groq.chat(messages: [\n      [\"role\": \"system\",\n       \"content\":\n       \"You are a helpful assistant that summarizes text concisely\"],\n      [\"role\": \"user\", \"content\": text]\n    ], maxTokens: maxTokens)\n}\n\nfunc questionAnswering(question: String) -> String {\n    Groq.chat(messages: [\n      [\"role\": \"system\",\n       \"content\":\n       \"You are a helpful assistant that answers questions directly and concisely.\"],\n      [\"role\": \"user\", \"content\": question]\n    ], maxTokens: 25)\n}\n\nfunc completions(promptText: String, maxTokens: Int = 25) -> String {\n    Groq.chat(messages: [\n        [\"role\": \"system\", \"content\": \"You complete text\"],\n        [\"role\": \"user\", \"content\": promptText]],\n        maxTokens: maxTokens)\n}\n

\n\n\n\n

\nExplanation of the Swift Groq API Code

\n\n

\n1. Setting Up the API

The Groq struct is designed to interact with the Groq API, mimicking OpenAI’s API.
\nAPI Key: Retrieved from the environment variable GROQ_API_KEY.
\nBase URL: The API’s base endpoint is https://api.groq.com/openai/v1/.
\nModel: The model being used is predefined as llama3-8b-8192.

\n\n

\n2. Structure of a Chat Request

A private struct, ChatRequest, defines the JSON payload for requests:\n
- \nmodel: The model name.
- \nmessages: A history of the conversation.
- \nmax_tokens: Limits the number of tokens in the response.
- \ntemperature: Controls randomness in the responses.
\n

\n\n

\n3. Making an HTTP POST Request

The makeRequest function handles API communication:\n
- Constructs the full URL by appending the endpoint to the base URL.
- Sets up a POST request with:\n
  - JSON content type.
  - Authorization header using the API key.
  \n
- Encodes the request body into JSON using JSONEncoder.
- Sends the request asynchronously but waits for the response using a semaphore.
- Parses the response data into a string.
\n

\n\n

\n4. Chat Functionality

The chat function simplifies sending messages to the API:\n
- Constructs a ChatRequest object with the given parameters.
- Sends the request to the /chat/completions endpoint.
- Processes the JSON response to extract the model’s reply from the choices array.
\n

\n\n

\n5. Usage Functions

summarize\n- Summarizes a text.\n- Sends a conversation history where the system is described as “a helpful assistant that summarizes text concisely.”

\n\n

1 summarize(text: String, maxTokens: Int = 40)\n

\n\n\n\n

questionAnswering\n- Answers a user-provided question directly.\n- Sends a conversation history where the system is described as “a helpful assistant that answers questions directly and concisely.”

\n\n

completions\n- Generates continuations for a given user prompt.

\n\n

\nRunning the Tests

\n\n

Here is the test/example code for this library:

\n\n

import XCTest\n@testable import Groq_swift\n\nfinal class Groq_swiftTests: XCTestCase {\n  func testExample() {\n    print(\"Starting tests...\")\n    let prompt = \"He walked to the river and looked at\"\n    let ret = completions(promptText: prompt, maxTokens: 200)\n    print(\"** ret from Groq API call:\", ret)\n    let question = \"Where was Leonardo da Vinci born?\"\n    let answer = questionAnswering(question: question)\n    print(\"** answer from Groq API call:\", answer)\n    let text = \"Jupiter is the fifth planet from the Sun and the largest in the Sola\\\nr System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-\\\na-half times that of all the other planets in the Solar System combined. Jupiter is \\\none of the brightest objects visible to the naked eye in the night sky, and has been\\\n known to ancient civilizations since before recorded history. It is named after the\\\n Roman god Jupiter.[19] When viewed from Earth, Jupiter can be bright enough for its\\\n reflected light to cast visible shadows,[20] and is on average the third-brightest \\\nnatural object in the night sky after the Moon and Venus.\"\n    let summary = summarize(text: text)\n    print(\"** generated summary: \", summary)\n  }\n}\n

\n\n\n\n

Here is sample output from this example use of the library:

\n\n

Starting tests...\n\n** ret from Groq API call: the calm water, feeling the warm sun on his face and the \\\ngentle breeze rustling his hair. The sound of the water lapping against the shore wa\\\ns soothing, and he closed his eyes, taking a deep breath to clear his mind.\n\n** answer from Groq API call: Leonardo da Vinci was born on April 15, 1452, in Vinci\\\n, Italy.\n\n** generated summary:  Here's a concise summary:\n\nJupiter is the largest planet in our Solar System, a gas giant with a mass 2.5 times\\\n that of all other planets combined. It's the fifth planet\n

\n\n\n\n\n

\nUsing the xAI Grok LLM

\n\n

xAI’s Grok is a large language model (LLM) developed by Elon Musk’s AI startup, xAI, to compete with leading AI systems like OpenAI’s GPT-4. Launched in 2023, Grok is designed to handle a variety of tasks, including answering questions, assisting with writing, and solving coding problems. It is integrated with the social media platform X (formerly Twitter), providing users with real-time information and a conversational AI experience.

\n\n

Grok has undergone several iterations, with Grok-2 being released in August 2024. This version introduced image generation capabilities, enhancing its versatility. xAI has also made Grok-1 open-source, allowing developers to access its weights and architecture for further research and application development.

\n\n

To support Grok’s development, xAI has invested in substantial computational resources, including the Colossus supercomputer, which utilizes 100,000 Nvidia H100 GPUs, positioning it as one of the most powerful AI training systems globally.

\n\n

\nImplementation of a Grok API Client Library

\n\n

The code for my xAI Grok client code can be found here:

\n\n

https://github.com/mark-watson/X_GROK_swift\n

\n\n\n\n

The Grok is similar to the OpenAI APIs so I copied the code we saw earlier that I wrote for OpenAI and made the simple modifications required to access Grok APIs (code discussion appears after this listing):

\n\n

import Foundation\n\n// xAI Grog LLM client library\n\nstruct X_GROK {\n    private static let key = ProcessInfo.processInfo.environment[\"X_GROK_API_KEY\"]!\n    private static let baseURL = \"https://api.x.ai/v1\"\n    \n    private static let MODEL = \"grok-beta\"\n\n    private struct ChatRequest: Encodable {\n        let model: String\n        let messages: [[String: String]]\n        let max_tokens: Int\n        let temperature: Double\n    }\n    \n    private static func makeRequest<T: Encodable>(endpoint: String, body: T)\n                                             -> String {\n        var responseString = \"\"\n        let url = URL(string: baseURL + endpoint)!\n        var request = URLRequest(url: url)\n        request.httpMethod = \"POST\"\n        request.setValue(\"application/json\", forHTTPHeaderField: \"Content-Type\")\n        request.setValue(\"Bearer \\(key)\", forHTTPHeaderField: \"Authorization\")\n        request.httpBody = try? JSONEncoder().encode(body)\n        \n        let semaphore = DispatchSemaphore(value: 0)\n        URLSession.shared.dataTask(with: request) { data, response, error in\n            if let error = error {\n                print(\"Error: \\(error)\")\n            }\n            if let data = data {\n                responseString = String(data: data, encoding: .utf8) ?? \"{}\"\n            }\n            semaphore.signal()\n        }.resume()\n        semaphore.wait()\n\n        return responseString\n    }\n    \n    static func chat(messages: [[String: String]], maxTokens: Int = 25,\n                                temperature: Double = 0.3) -> String {\n        let chatRequest = ChatRequest(\n            model: MODEL,\n            messages: messages,\n            max_tokens: maxTokens,\n            temperature: temperature\n        )\n        \n        let response = makeRequest(endpoint: \"/chat/completions\",\n                                   body: chatRequest)\n        guard let data = response.data(using: .utf8),\n              let json = try? JSONSerialization.jsonObject(with: data) as? [String: \\\nAny],\n              let choices = json[\"choices\"] as? [[String: Any]],\n              let firstChoice = choices.first,\n              let message = firstChoice[\"message\"]\n                                      as? [String: Any],\n              let content = message[\"content\"] as? String else {\n            return \"\"\n        }\n        return content\n    }\n}\n\n// Usage functions:\nfunc summarize(text: String, maxTokens: Int = 40) -> String {\n    X_GROK.chat(messages: [\n      [\"role\": \"system\",\n       \"content\":\n       \"You are a helpful assistant that summarizes text concisely.\"],\n      [\"role\": \"user\", \"content\": text]\n    ], maxTokens: maxTokens)\n}\n\nfunc questionAnswering(question: String) -> String {\n    X_GROK.chat(messages: [\n      [\"role\": \"system\",\n       \"content\":\n       \"You are a helpful assistant who answers questions directly and concisely.\"],\n      [\"role\": \"user\", \"content\": question]\n    ], maxTokens: 25)\n}\n\nfunc completions(promptText: String, maxTokens: Int = 25) -> String {\n    X_GROK.chat(messages: [[\"role\": \"user\", \"content\": promptText]],\n                           maxTokens: maxTokens)\n}\n

\n\n\n\n

This Swift code defines a client library, X_GROK, to interact with the xAI Grok Large Language Model (LLM) API. It leverages Swift’s Foundation framework to handle HTTP requests and JSON encoding/decoding. The library retrieves the API key from the environment variable X_GROK_API_KEY and sets the base URL for the API. It specifies a default model, grok-beta, for generating responses.

\n\n

The core functionality is encapsulated in the makeRequest function, which constructs and sends HTTP POST requests to the API. It accepts an endpoint and a request body conforming to the Encodable protocol. The function sets the necessary HTTP headers, including Content-Type and Authorization, and encodes the request body into JSON. To handle the asynchronous nature of network calls synchronously, it employs a semaphore, ensuring the function waits for the response before proceeding. The response is then returned as a string.

\n\n

The chat function utilizes makeRequest to send chat messages to the API. It constructs a ChatRequest struct with parameters like the model, messages, maximum tokens, and temperature. After receiving the response, it parses the JSON to extract the generated content. Additionally, the code provides utility functions summarize, questionAnswering, and completions which use the chat function to perform specific tasks such as text summarization, question answering, and text completion, respectively.

\n\n

Here is the test/example code for this library:

\n\n

import XCTest\n@testable import X_GROK_swift\n\nfinal class X_GROK_swiftTests: XCTestCase {\n  func testExample() {\n    print(\"Starting tests...\")\n    let prompt = \"He walked to the river and looked at\"\n    let ret = completions(promptText: prompt, maxTokens: 200)\n    print(\"** ret from X_GROK API call:\", ret)\n    let question = \"Where was Leonardo da Vinci born?\"\n    let answer = questionAnswering(question: question)\n    print(\"** answer from X_GROK API call:\", answer)\n    let text = \"Jupiter is the fifth planet from the Sun and the largest in the Sola\\\nr System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-\\\na-half times that of all the other planets in the Solar System combined. Jupiter is \\\none of the brightest objects visible to the naked eye in the night sky, and has been\\\n known to ancient civilizations since before recorded history. It is named after the\\\n Roman god Jupiter.[19] When viewed from Earth, Jupiter can be bright enough for its\\\n reflected light to cast visible shadows,[20] and is on average the third-brightest \\\nnatural object in the night sky after the Moon and Venus.\"\n    let summary = summarize(text: text)\n       print(\"** generated summary: \", summary)\n    }\n}\n

\n\n\n\n

Here is the example code output:

\n\n

Starting tests...\n** ret from X_GROK API call: He walked to the river and looked at the water flowing \\\ngently by. The serene scene provided a moment of peace, as he watched the ripples da\\\nnce in the sunlight. The sound of the water was soothing, almost like a lullaby, cal\\\nming his thoughts and grounding him in the present. He felt a deep connection to nat\\\nure, the river's timeless flow reminding him of life's continuous journey.\n** answer from X_GROK API call: Leonardo da Vinci was born in the town of Vinci, in \\\nthe region of Tuscany, Italy.\n** generated summary:  Jupiter, the fifth planet from the Sun, is the largest in our\\\n Solar System, classified as a gas giant with a mass significantly greater than all \\\nother planets combined. It's one of the brightest objects\n

\n\n\n\n\n

\nUsing Ollama to Run Local LLMs

\n\n

Ollama is a program and framework written in Go that allows you to download, run models on the command line, and call using a REST style interface. You need to downnload the Ollama executable for your operation system at https://ollama.com.

\n\n

Similarly to our use of a third party for accessing the Anthropic Clause models, here we will not write a wrapper libary. The example code for ths chapter is in the test code for the Swift project in the GitHub repository https://github.com/mark-watson/Ollama_swift_examples.

\n\n

We use the library in the GitHub repository https://github.com/mattt/ollama-swift.

\n\n

\nRunning the Ollama Service

\n\n

Assuming you have Ollama installed, download the following model that required two gigabytes of disk space:

\n\n

ollama pull llama3.2:latest\n

\n\n\n\n

When the model is downloaded it is also cached for future use on your laptop.

\n\n

Here is the test/example code we will run:

\n\n

import XCTest\nimport Ollama\n\nfinal class Ollama_swift_examplesTests: XCTestCase {\n    let text1 = \"If Mary is 42, Bill is 27, and Sam is 51, what are their pairwise a\\\nge differences.\"\n    let client = Ollama.Client.default // http://localhost:11434 endpoint\n    func testExample() async throws {\n      let response = try await client.chat(\n        model: \"llama3.2:latest\",\n        messages: [\n            .system(\"You are a helpful assistant who completes text and also answers\\\n questions. You are always concise.\"),\n            .user(text1),\n            .user(\"what if Sam is 52?\")\n        ])\n        print(response.message.content)\n    }\n}\n

\n\n\n\n

The output looks like:

\n\n

Pairwise age differences:\n\n- Mary - Bill: |42 - 27| = 15\n- Mary - Sam: |42 - 51| = 9\n- Bill - Sam: |27 - 51| = 24\n\nIf Sam is 52:\n- Mary - Bill: |42 - 27| = 15\n- Mary - Sam: |42 - 52| = 10\n- Bill - Sam: |27 - 52| = 25\n

\n\n\n\n

The ollama_swift library also supports text generation. You can also do single shot text generation using the code in the previous example, but only using one user call, for example:

\n\n

final class Ollama_swift_examplesTests: XCTestCase {\n    let text1 = \"What is the capital of Germany?\"\n    let client = Ollama.Client.default\n    func testExample() async throws {\n      let response = try await client.chat(\n        model: \"llama3.2:latest\",\n        messages: [\n            .system(\"You are a helpful assistant who completes text and also answers\\\n questions. You are always concise.\"),\n            .user(text1),\n        ])\n        print(response.message.content)\n    }\n}\n

\n\n\n\n

The output looks like:

\n\n

The capital of Germany is Berlin.\n

\n\n\n\n

\nOllama Wrap Up

\n\n

This is a short chapter but an important one. I do over half my work with LLMs running locally on my laptop using Ollama, with the rest of my work using OpenAI, Anthropic, and Groq commercial APIs.

\n\n\n

\nUsing Apple’s MLX Framework to Run Local LLMs

\n\n

Apple’s MLX framework is an efficient way to use LLMs embedded in applications written in Swift using the SwiftUI user interface library for macOS, iOS, and iPadOS.

\n\n

It is difficult to create simple command line Swift apps using MLX but there are several complete MLX, Swift, and SwiftUI demo applications that you can use to start your own projects. Here we will use the LLMEval application from the GitHub repository https://github.com/ml-explore/mlx-swift-examples.

\n\n

\nMLX Framework History

\n\n

Apple’s MLX framework, introduced in December 2023, is a key part of Apple’s strategy to support AI on its hardware platforms by leveraging the unique capabilities of Apple Silicon, including the M1, M2, M3, and M4 series. Designed as an open-source, NumPy-like array framework, MLX optimizes machine learning workloads, particularly large language models (LLMs), by utilizing Apple Silicon’s unified architecture that integrates CPU, GPU, Neural Engine, and shared memory. This architecture eliminates data transfer bottlenecks, enabling faster and more efficient ML tasks, such as training and deploying LLMs directly on devices like MacBooks and iPhones. MLX aligns with Apple’s privacy-focused approach by supporting on-device processing, enhancing performance for applications like natural language processing, speech recognition, and content generation while offering a seamless transition for Python or Swift ML engineers familiar with frameworks like NumPy and PyTorch. MLX stands out by leveraging Apple’s unified memory architecture, allowing shared memory access between CPU and GPU, which eliminates data transfer overhead and accelerates machine learning tasks, especially with large datasets.

\n\n

\nMLX Resources on GitHub

\n\n

In this chapter we will look at an example application that is part of the Swift MLX Examples project. After working through this example, the following resources on GitHub are worth looking at:

\n\n

https://github.com/ml-explore/mlx-swift: The Swift API for MLX, enabling integration with Swift-based projects.
https://github.com/ml-explore/mlx-swift-examples: Examples showcasing the use of MLX with Swift.

\n\n

You can find the documentation here:

\n\n

https://swiftpackageindex.com/ml-explore/mlx-swift/0.18.0/documentation/mlx.

\n\n

These repositories provide a comprehensive set of tools and examples to effectively utilize MLX for machine learning tasks on Apple silicon. There are many other repositories for MLX and Python and if you need to perform tasks like fine tuning a MLX model, that task should probably be done using Python.

\n\n

\nExample Application for MLX Swift Examples Repository

\n\n

You will want to download the complete MLX Swift examples repository:

\n\n

git clone https://github.com/ml-explore/mlx-swift-examples.git\n

\n\n\n\n

Open the top level XCode project by:

\n\n

cd mlx-swift-examples\nopen mlx-swift-examples.xcodeproj\n

\n\n\n\n

Here is the file browser view of this project:

\n\n\n

\n\n\n

Running the LLMEval project:

\n\n\n

Initially the model is downloaded and cached on your laptop for future use. Here is the app used to solve a simple word problem:

\n\n\n

\nAnalysis of Swift and SwiftUI Code in the LLMEval Application

\n\n

This example is part of the Swift MLX Examples project that currently has twenty contributors and a thousand stars on GitHub https://github.com/ml-explore/mlx-swift-examples.

\n\n

Unfortunately the SwiftUI user interface code is mixed in with the code that uses MLX. Let’s walk through the code:

\n\n

Here is a walk through a Swift-based program using Apple’s frameworks for Machine Learning and Language Models with the code interspersed with explanations.

\n\n

\nImports

\n\n

import LLM\nimport MLX\nimport MLXRandom\nimport MarkdownUI\nimport Metal\nimport SwiftUI\nimport Tokenizers\n

\n\n\n\n

These imports bring in essential libraries:

\n\n

LLM and MLX for working with language models.
MarkdownUI for rendering Markdown content.
SwiftUI for creating the user interface.
Tokenizers for tokenizing text.

\n\n

\nThe ContentView Struct

\n\n

The ContentView struct defines the main interface of the app.

\n\n

State Variables

\n\n

struct ContentView: View {\n\n  @State var prompt = \"\"\n  @State var llm = LLMEvaluator()\n  @Environment(DeviceStat.self) private var deviceStat\n

\n\n\n\n

In this code snippet:

\n\n

@State allows the view to track changes in the prompt and llm instances.
@Environment fetches device statistics, such as GPU memory usage.

\n\n

Display Style Enum

\n\n

  enum displayStyle: String, CaseIterable, Identifiable {\n    case plain, markdown\n    var id: Self { self }\n  }\n  \n  @State private var selectedDisplayStyle = displayStyle.markdown\n

\n\n\n\n

In this code snippet:

\n\n

\ndisplayStyle defines whether the output is plain text or Markdown.
A segmented picker toggles between the two styles.

\n\n

\nUI Layout

\n\n

Input Section

\n\n

  var body: some View {\n    VStack(alignment: .leading) {\n      VStack {\n       HStack {\n         Text(llm.modelInfo).textFieldStyle(.roundedBorder)\n         Spacer()\n         Text(llm.stat)\n       }\n       HStack {\n         Spacer()\n         if llm.running {\n            ProgressView().frame(maxHeight: 20)\n            Spacer()\n          }\n          Picker(\"\", selection: $selectedDisplayStyle) {\n            ForEach(displayStyle.allCases, id: \\.self) {\n              option in\n                Text(option.rawValue.capitalized)\n                        .tag(option)\n            }\n\n           }.pickerStyle(.segmented)\n        }\n      }\n

\n\n\n\n

This code displays model information and statistics.

\n\n

Output Section

\n\n

      ScrollView(.vertical) {\n        ScrollViewReader { sp in\n          Group {\n            if selectedDisplayStyle == .plain {\n                Text(llm.output)\n                    .textSelection(.enabled)\n            } else {\n                Markdown(llm.output)\n                    .textSelection(.enabled)\n            }\n          }\n          .onChange(of: llm.output) { _, _ in\n            sp.scrollTo(\"bottom\")\n          }\n        }\n      }\n\n      HStack {\n        TextField(\"prompt\", text: $prompt)\n                    .onSubmit(generate)\n                    .disabled(llm.running)\n        Button(\"generate\", action: generate)\n                    .disabled(llm.running)\n       }\n      }\n

\n\n\n\n

The ScrollView shows the model’s output, which updates dynamically as the model generates text.

\n\n

Toolbar

\n\n

      .toolbar {\n         ToolbarItem {\n           Label(\n            \"Memory Usage: \\(deviceStat.gpuUsage.activeMemory.formatted(.byteCount(s\\\ntyle: .memory)))\",\n            systemImage: \"info.circle.fill\"\n           )\n          }\n          ToolbarItem(placement: .primaryAction) {\n             Button {\n               Task {\n                copyToClipboard(llm.output)\n               }\n              } label: {\n                Label(\"Copy Output\", systemImage: \"doc.on.doc.fill\")\n              }\n           }\n        }\n

\n\n\n\n

The toolbar includes:

\n\n

GPU memory usage information.
A “Copy Output” button to copy the generated text.

\n\n

\nThe LLMEvaluator Class

\n\n

This class handles the logic for loading and generating text with the language model.

\n\n

Core Properties

\n\n

@Observable\n@MainActor\nclass LLMEvaluator {\n  var running = false\n  var output = \"\"\n  var modelInfo = \"\"\n  var stat = \"\"\n  let modelConfiguration = ModelConfiguration.phi3_5_4bit\n  /// parameters controlling the output\n  let generateParameters = GenerateParameters(temperature: 0.6)\n  let maxTokens = 240\n\n  /// update the display every N tokens -- 4 looks like it updates continuously\n  /// and is low overhead.  observed ~15% reduction in tokens/s when updating\n  /// on every token\n  let displayEveryNTokens = 4\n\n  enum LoadState {\n        case idle\n        case loaded(ModelContainer)\n  }\n\n  var loadState = LoadState.idle\n

\n\n\n\n

This code snippet:

\n\n

Tracks the model state and output.
Configures the model (phi3_5_4bit).

\n\n

Loading the Model (if required)

\n\n

  /// load and return the model -- can be called\n  /// multiple times, subsequent calls will\n  /// just return the loaded model\n \n  func load() async throws -> ModelContainer {\n    switch loadState {\n    case .idle:\n        MLX.GPU.set(cacheLimit: 20 * 1024 * 1024)\n        let modelContainer =\n          try await LLM.loadModelContainer(configuration: modelConfiguration) {\n            [modelConfiguration] progress in\n            Task { @MainActor in\n                self.modelInfo = \"Downloading \\(modelConfiguration.name): \\(Int(prog\\\nress.fractionCompleted * 100))%\"\n            }\n        }\n        self.modelInfo = \"Loaded \\(modelConfiguration.id). Weights: \\(numParams / (1\\\n024*1024))M\"\n        loadState = .loaded(modelContainer)\n        return modelContainer\n    case .loaded(let modelContainer):\n        return modelContainer\n    }\n  }\n

\n\n\n\n

This code snippet:

\n\n

Downloads and caches the model.
Updates modelInfo during the download.

\n\n

Generating Output

\n\n

  func generate(prompt: String) async {\n    guard !running else { return }\n    running = true\n    self.output = \"\"\n\n    do {\n        let modelContainer = try await load()\n        let messages = [[\"role\": \"user\", \"content\": prompt]]\n        let promptTokens = try await modelContainer.perform { _, tokenizer in\n            try tokenizer.applyChatTemplate(messages: messages)\n        }\n\n        let result = await modelContainer.perform { model, tokenizer in\n            LLM.generate(\n                promptTokens: promptTokens,\n                parameters: generateParameters, model: model,\n                tokenizer: tokenizer,\n                extraEOSTokens: modelConfiguration.extraEOSTokens\n            ) { tokens in\n                if tokens.count % displayEveryNTokens == 0 {\n                    let text = tokenizer.decode(tokens: tokens)\n                    Task { @MainActor in\n                        self.output = text\n                    }\n                }\n                if tokens.count >= maxTokens {\n                    return .stop\n                } else {\n                    return .more\n                }\n            }\n        }\n    } catch {\n        output = \"Failed: \\(error)\"\n    }\n    running = false\n  }\n}\n

\n\n\n\n

This code snippet:

\n\n

Prepares the prompt for the model.
Generates tokens and dynamically updates the view.

\n\n

This program demonstrates how to integrate ML and UI components for interactive LLM-based applications in Swift.

\n\n

This code example uses the MIT License so you can modify the example code if you need to write a combined SwiftUI GUI app that uses LLM-based text generation.

\n\n\n

\nPart 3: Apple’s CoreML and NLP Libraries

\n\n

In this part we cover:

\n\n

Short introduction to the ideas behind Deep Learning
Introduction of CoreML
Examples using CoreML
Introduction of NLP
Examples using NLP libraries

\n\n

This section used to contain Apple CoreML examples to train a back-propagation model from the University of Wisconsin cancer data set. As of April 2022, these example do not work because of a problem with latest CreateML library so this material has been removed from this book.

\n\n\n

\nDeep Learning Introduction

\n\n

Apple’s work in smoothly integrating deep learning into their developer tools for macOS, iOS, and iPadOS applications is in my opinion nothing short of brilliant. We will finish this book with an application that uses two deep learning models that provide almost all of the functionality of the application.

\n\n

Before diving into Apple’s CoreML libraries in later chapters we will take a shallow dive into the principles of deep learning and take a lay-of-the-land look at the type of most commonly used models. This chapter has no example programs and is intended as background material.

\n\n

Most of my professional career since 2014 has involved Deep Learning, mostly with TensorFlow using the Keras APIs. In the late 1980s I was on a DARPA neural network technology advisory panel for a year, I wrote the first prototype of the SAIC ANSim neural network library commercial product, and I wrote the neural network prediction code for a bomb detector my company designed and built for the FAA for deployment in airports. More recently I have used GAN (generative adversarial networks) models for synthesizing numeric spreadsheet data and LSTM (long short term memory) models to synthesize highly structured text data like nested JSON and for NLP (natural language processing). I have also written a product recommendation model for an online store using TensorFlow Recommenders. I have several USA and European patents using neural network and Deep Learning technology.

\n\n

Here we will learn a vocabulary for discussing Deep Learning neural network models and look at possible architectures.

\n\n

If you want to use Deep Learning professionally, there are two specific online resources that I recommend: Andrew Ng leads the efforts at deeplearning.ai and Jeremy Howard leads the efforts at fast.ai.

\n\n

There are many Deep Learning neural architectures in current practical use; a few types that I use are:

\n\n

Multi-layer perceptron networks with many fully connected layers. An input layer contains placeholders for input data. Each element in the input layer is connected by a two-dimensional weight matrix to each element in the first hidden layer. We can use any number of fully connected hidden layers, with the last hidden layer connected to an output layer.
Convolutional networks for image processing and text classification. Convolutions, or filters, are small windows that can process input images (filters are two-dimensional) or sequences like text (filters are one-dimensional). Each filter uses a single set of learned weights independent of where the filter is applied in an input image or input sequence.
Autoencoders have the same number of input layer and output layer elements with one or more hidden fully connected layers. Autoencoders are trained to produce the same output as training input values using a relatively small number of hidden layer elements. Autoencoders are capable of removing noise in input data.
LSTM (long short term memory) process elements in a sequence in order and are capable of remembering patterns that they have seen earlier in the sequence.
GAN (generative adversarial networks) models comprise two different and competing neural models, the generator and the discriminator. GANs are often trained on input images (although in my work I have applied GANs to two-dimensional numeric spreadsheet data). The generator model takes as input a “latent input vector” (this is just a vector of specific size with random values) and generates a random output image. The weights of the generator model are trained to produce random images that are similar to how training images look. The discriminator model is trained to recognize if an arbitrary output image is original training data or an image created by the generator model. The generator and discriminator models are trained together.

\n\n

The core functionality of libraries like TensorFlow are written in C++ and take advantage of special hardware like GPUs, custom ASICs, and devices like Google’s TPUs. Most people who work with Deep Learning models don’t need to even be aware of the low level optimizations used to make training and using Deep Learning models more efficient. That said, in the following section I am going to show you how simple neural networks are trained and used.

\n\n

\nSimple Multi-layer Perceptron Neural Networks

\n\n

I use the terms Multi-layer perceptron neural networks, backpropagation neural networks and delta-rule networks interchangeably. Backpropagation refers to the model training process of calculating the output errors when training inputs are passed in the forward direction from input layer, to hidden layers, and then to the output layer. There will be an error which is the difference between the calculated outputs and the training outputs. This error can be used to adjust the weights from the last hidden layer to the output layer to reduce the error. The error is then backprogated backwards through the hidden layers, updating all weights in the model. I have detailed example code in several of my older artificial intelligence books. Here I am satisfied to give you an intuition of how simple neural networks are trained.

\n\n

The basic idea is that we start with a network initialized with random weights and for each training case we propagate the inputs through the network towards the output neurons, calculate the output errors, and back-up the errors from the output neurons back towards the input neurons in order to make small changes to the weights to lower the error for the current training example. We repeat this process by cycling through the training examples many times.

\n\n

The following figure shows a simple backpropagation network with one hidden layer. Neurons in adjacent layers are connected by floating point connection strength weights. These weights start out as small random values that change as the network is trained. Weights are represented in the following figure by arrows; in the code the weights connecting the input to the output neurons are represented as a two-dimensional array.

\n\n\n

\"Example — Example Backpropagation network with One Hidden Layer

\n\n\n

Each non-input neuron has an activation value that is calculated from the activation values of connected neurons feeding into it, gated (adjusted) by the connection weights. For example, in the above figure, the value of Output 1 neuron is calculated by summing the activation of Input 1 times weight W1,1 and Input 2 activation times weight W2,1 and applying a “squashing function” like Sigmoid or Relu (see figures below) to this sum to get the final value for Output 1’s activation value. We want to flatten activation values to a relatively small range but still maintain relative values. To do this flattening we use the Sigmoid function that is seen in the next figure, along with the derivative of the Sigmoid function which we will use in the code for training a network by adjusting the weights.

\n\n\n

\"Sigmoid — Sigmoid Function and Derivative of Sigmoid Function (SigmoidP)

\n\n\n

Simple neural network architectures with just one or two hidden layers are easy to train using backpropagation and I have from scratch code (using no libraries) for this several of my previous books. However, here we are using Hy to write models using the TensorFlow framework which has the huge advantage that small models you experiment with on your laptop can be scaled to more parameters (usually this means more neurons in hidden layers which increases the number of weights in a model) and run in the cloud using multiple GPUs.

\n\n

Except for pedantic purposes, I now never write neural network code from scratch. I take instead advantage of the many person-years of engineering work put into the development of frameworks like TensorFlow, PyTorch, mxnet, etc. We now move on to two examples built with TensorFlow.

\n\n

\nDeep Learning

\n\n

Deep Learning models are generally understood to have many more hidden layers than simple multi-layer perceptron neural networks and often comprise multiple simple models combined together in series or in parallel.\nComplex architectures can be iteratively developed by manually adjusting the size of model components, changing the components, etc. Alternatively, model architecture search can be automated. At Capital One I used Google’s \nAdaNet project that efficiently searches for effective model architectures inside a single TensorFlow session. Now all major cloud compute provides support some form of AutoML. You need to make a decision for yourself how much effort you want to put into deeply understanding the technology, or simply learning how to use pre-trained models.

\n\n\n

\nNatural Language Processing Using Apple’s Natural Language Framework

\n\n

I have been working in the field of Natural Language Processing (NLP) since 1985 so I ‘lived through’ the revolutionary change in NLP that has occurred since 2014: Deep Learning results out-classed results from previous symbolic methods.

\n\n

https://developer.apple.com/documentation/naturallanguage

\n\n

I will not cover older symbolic methods of NLP here, rather I refer you to my previous books Practical Artificial Intelligence Programming With Java, Loving Common Lisp, or the Savvy Programmer’s Secret Weapon, and Haskell Tutorial and Cookbook for examples. We get better results using Deep Learning (DL) for NLP and the libraries that Apple provides.

\n\n

You will learn how to apply both DL and NLP by using the state-of-the-art full-feature libraries that Apple provides in their iOS and macOS development tools.

\n\n

\nUsing Apple’s NaturalLanguage Swift Library

\n\n

We will use one of Apple’s NLP libraries consisting of pre-built models in the last chapter of this book. In order to fully understand the example in the last chapter you will need to read Apple’s high-level discussion of using CoreML https://developer.apple.com/documentation/coreml and their specific support for NLP https://developer.apple.com/documentation/naturallanguage/.

\n\n

There are many pre-trained CoreML compatible models on the web, both from Apple and also from third party (e.g., https://github.com/likedan/Awesome-CoreML-Models).

\n\n

Apple also provides tools for converting TensorFlow and PyTorch models to be compatible with CoreML https://coremltools.readme.io/docs.

\n\n

\nA simple Wrapper Library for Apple’s NLP Models

\n\n

I will not go into too much detail here but I created a small wrapper library for Apple’s NLP models that will make it easier for you to jump in and have fun experimenting with them: https://github.com/mark-watson/Nlp_swift.

\n\n

The main library implementation file uses the @available(OSX 10.13, *) attribute to indicate that the following function is available on macOS 10.13 and later versions.

\n\n

 1 import Foundation\n 2 import NaturalLanguage\n 3 \n 4 let tagger = NSLinguisticTagger(tagSchemes:[.tokenType, .language, .lexicalClass,\n 5     .nameType, .lemma], options: 0) \n 6 let options: NSLinguisticTagger.Options = [.omitPunctuation, .omitWhitespace,\n 7     .joinNames]\n 8 \n 9 @available(OSX 10.13, *)\n10 public func getEntities(for text: String) -> [(String, String)] {\n11     var words: [(String, String)] = []\n12     tagger.string = text\n13     let range = NSRange(location: 0, length: text.utf16.count)\n14     tagger.enumerateTags(in: range, unit: .word, scheme: .nameType,\n15     options: options) { tag, tokenRange, stop in\n16         let word = (text as NSString).substring(with: tokenRange)\n17         words.append((word, tag?.rawValue ?? \"unkown\"))\n18     }\n19     return words\n20 }\n21 \n22 @available(OSX 10.13, *)\n23 public func getLemmas(for text: String) -> [(String, String)] {\n24     var words: [(String, String)] = []\n25     tagger.string = text\n26     let range = NSRange(location: 0, length: text.utf16.count)\n27     tagger.enumerateTags(in: range, unit: .word, scheme: .lemma, \n28             options: options) { tag, tokenRange, stop in\n29         let word = (text as NSString).substring(with: tokenRange)\n30         words.append((word, tag?.rawValue ?? \"unkown\"))\n31     }\n32     return words\n33 }\n

\n\n\n\n

The public function getEntities takes a String parameter called text and returns an array of tuples containing (String, String). Here’s a breakdown of what this function does:

\n\n

The function initializes an empty array called words to store the extracted entities.
The line tagger.string = text sets the input text for a tagger object. The tagger is an instance of NSLinguisticTagger, which is a natural language processing class provided by Apple’s Foundation framework.
The next line creates an NSRange object called range that represents the entire length of the input text.
The tagger.enumerateTags(in:range, unit:.word, scheme:.nameType, options:options) method is called to iterate over the words in the input text and extract their associated tags. The in: parameter specifies the range of the text to process. The unit: parameter specifies that the enumeration should be done on a word-by-word basis. The scheme: parameter specifies the linguistic scheme to use, in this case, the .nameType scheme, which is used to identify named entities. The options: parameter specifies additional options or settings for the tagger.
Inside the enumeration block, the code retrieves the current word and its associated tag using the tokenRange and tag parameters.
The line let word = (text as NSString).substring(with: tokenRange) extracts the substring corresponding to the current word using tokenRange.
The line words.append((word, tag?.rawValue ?? “unknown”)) appends a tuple containing the extracted word and its associated tag to the words array. If the tag is nil, it uses the default value of “unknown”.
Finally, the words array is returned, which contains all the extracted entities (words and their associated tags) from the input text.

\n\n

The public function called getLemmas that takes a String parameter called text and returns an array of tuples containing (String, String). Here’s a breakdown of what the function getLemmas is very similar to the last function getEntities. The function getLemmas does the following:

\n\n

The function initializes an empty array called words to store the extracted lemmas.
The line tagger.string = text sets the input text for a tagger object.
The next line creates an NSRange object called range that represents the entire length of the input text.
The tagger.enumerateTags(in:range, unit:.word, scheme:.lemma, options: options) method is called to iterate over the words in the input text and extract their corresponding lemmas.
Inside the enumeration block, the code retrieves the current word and its associated lemma using the tokenRange and tag parameters.
The line let word = (text as NSString).substring(with: tokenRange) extracts the substring corresponding to the current word using tokenRange.
Finally, the words array is returned, which contains all the extracted lemmas (words and their associated base forms) from the input text.

\n\n

In summary, function getLemmas uses the NSLinguisticTagger to perform linguistic analysis on a given text and extract the base forms (lemmas) of words. The lemmas are then stored in an array of tuples and returned as the result of the function.

\n\n

Here is some test code:

\n\n

 1 let quote = \"President George Bush went to Mexico with IBM representatives. Here's t\\\n 2 o the crazy ones. The misfits. The rebels. The troublemakers. The round pegs in the \\\n 3 square holes. The ones who see things differently. They're not fond of rules. And th\\\n 4 ey have no respect for the status quo. You can quote them, disagree with them, glori\\\n 5 fy or vilify them. About the only thing you can't do is ignore them. Because they ch\\\n 6 ange things. They push the human race forward. And while some may see them as the cr\\\n 7 azy ones, we see genius. Because the people who are crazy enough to think they can c\\\n 8 hange the world, are the ones who do. - Steve Jobs (Founder of Apple Inc.)\"\n 9 if #available(OSX 10.13, *) {\n10             print(\"\\nEntities:\\n\")\n11             print(getEntities(for: quote))\n12             print(\"\\nLemmas:\\n\")\n13             print(getLemmas(for: quote))\n14 }\n

\n\n\n\n

Here is an edited listing of the output with most of the output removed for brevity:

\n\n

 1 Entities:\n 2 \n 3 [(\"President\", \"OtherWord\"), (\"George Bush\", \"PersonalName\"), (\"went\", \"OtherWord\"),\\\n 4  (\"to\", \"OtherWord\"), (\"Mexico\", \"PlaceName\"), (\"with\", \"OtherWord\"), (\"IBM\", \"Organ\\\n 5 izationName\"), \n 6   ...]\n 7 \n 8 Lemmas:\n 9 \n10 [(\"President\", \"President\"), (\"George Bush\", \"George\"), (\"went\", \"go\"), (\"to\", \"to\")\\\n11 , (\"Mexico\", \"Mexico\"),\n12   ...]\n

\n\n\n\n\n

\nDocuments Question Answering Using OpenAI GPT4 APIs and a Local Embeddings Vector Database

\n\n

The examples in this chapter are inspired by the Python LangChain and LlamaIndex projects, with just the parts I need for my projects written from scratch in Common Lisp. I wrote a Python book “LangChain and LlamaIndex Projects Lab Book: Hooking Large Language Models Up to the Real World Using GPT-3, ChatGPT, and Hugging Face Models in Applications” in March 2023: https://leanpub.com/langchain that you might also be interested in.

\n\n

The GitHub repository for this example can be found here: https://github.com/mark-watson/Docs_QA_Swift.

\n\n

The entire example is in one Swift source file main.swift. All of the program listings in this chapter can be found in this single source file.

\n\n

We use two models in this example: a vector embedding model\nand a gpt-4o-mini conversation model (see bottom of this file).\nThe vector embedding model is used to generate a vector embedding.\nThe gpt-4o-mini model is used to generate a response to a prompt.\nThe vector embedding model is used to compare the similarity of two\nprompts.

\n\n

\nExtending the String Class

\n\n

 1 import Foundation\n 2 import NaturalLanguage\n 3 \n 4 // String utilities:\n 5 \n 6 extension String {\n 7     func removeCharacters(from forbiddenChars: CharacterSet) -> String {\n 8         let passed = self.unicodeScalars.filter { !forbiddenChars.contains($0) }\n 9         return String(String.UnicodeScalarView(passed))\n10     }\n11 \n12     func removeCharacters(from: String) -> String {\n13         return removeCharacters(from: CharacterSet(charactersIn: from))\n14     }\n15     func plainText() -> String {\n16         return self.removeCharacters(from:\n17                                      \"\\\"`()%$#@[]{}<>\").replacingOccurrences(of: \"\\n\\\n18 \",\n19                                      with: \" \")\n20     }\n21 }\n

\n\n\n\n

\nImplementing a Local Vector Database for Document Embeddings

\n\n

 1 let openai_key = ProcessInfo.processInfo.environment[\"OPENAI_KEY\"]!\n 2 \n 3 let openAiHost = \"https://api.openai.com/v1/embeddings\"\n 4 \n 5 func openAiHelper(body: String)  -> String {\n 6     var ret = \"\"\n 7     var content = \"{}\"\n 8     let requestUrl = URL(string: openAiHost)!\n 9     var request = URLRequest(url: requestUrl)\n10     request.httpMethod = \"POST\"\n11     request.httpBody = body.data(using: String.Encoding.utf8);\n12     request.setValue(\"application/json\", forHTTPHeaderField: \"Content-Type\")\n13     request.setValue(\"Bearer \" + openai_key, forHTTPHeaderField: \"Authorization\")\n14     let task = URLSession.shared.dataTask(with: request) { (data, response, error) in\n15         if let error = error {\n16             print(\"-->> Error accessing OpenAI servers: \\(error)\")\n17             return\n18         }\n19         if let data = data, let s = String(data: data, encoding: .utf8) {\n20             content = s\n21             //print(\"** s=\", s)\n22             CFRunLoopStop(CFRunLoopGetMain())\n23         }\n24     }\n25     task.resume()\n26     CFRunLoopRun()\n27     let c = String(content)\n28     let i1 = c.range(of: \"\\\"embedding\\\":\")\n29     if let r1 = i1 {\n30         let i2 = c.range(of: \"]\")\n31         if let r2 = i2 {\n32             ret = String(String(String(c[r1.lowerBound..<r2.lowerBound]).dropFirst(1\\\n33 5)).dropLast(2))\n34         }\n35     }\n36     return ret\n37 }\n38 \n39 public func embeddings(someText: String) -> [Float] {\n40     let body: String = \"{\\\"input\\\": \\\"\" + someText + \"\\\", \\\"model\\\": \\\"text-embeddin\\\n41 g-ada-002\\\" }\"\n42     return readList(openAiHelper(body: body))\n43 }\n44 \n45 func dotProduct(_ list1: [Float], _ list2: [Float]) -> Float {\n46     if list1.count != list2.count {\n47         //fatalError(\"Lists must have the same length.\")\n48         print(\"WARNING: Lists must have the same length: \\(list1.count) != \\(list2.c\\\n49 ount)\")\n50         return 0.0\n51     }\n52     \n53     var result: Float = 0\n54     \n55     for i in 0..<list1.count {\n56         result += list1[i] * list2[i]\n57     }\n58     \n59     return result\n60 }\n

\n\n\n\n

The source file contains example code for creating embeddings and using dot product work to find semantic similarity:

\n\n

1 let emb1 = embeddings(someText: \"John bought a new car\")\n2 let emb2 = embeddings(someText: \"Sally drove to the store\")\n3 let emb3 = embeddings(someText: \"The dog saw a cat\")\n4 let dotProductResult1 = dotProduct(emb1, emb2)\n5 print(dotProductResult1)\n6 let dotProductResult2 = dotProduct(emb1, emb3)\n7 print(dotProductResult2)\n

\n\n\n\n

The output is:

\n\n

1 0.8416926\n2 0.79411536\n

\n\n\n\n

For this example, we use an in-memory store of embedding vectors and chunk text.\nA text document is broken into smaller chunks of text. Each chunk is embedded\nand stored in the embeddingsStore. The chunk text is stored in the chunks array.\nThe embeddingsStore and chunks array are used to find the most similar chunk\nto a prompt. The most similar chunk is used to generate a response to the prompt.

\n\n

 1 var embeddingsStore: Array<[Float]> = Array()\n 2 var chunks: Array<String> = Array()\n 3 \n 4 func addEmbedding(_ embedding: [Float]) {\n 5     embeddingsStore.append(embedding)\n 6     //print(\"Added embedding: count=\\(embeddingsStore.count)  \\(embedding)\")\n 7 }\n 8 \n 9 func addChunk(_ chunk: String) {\n10     chunks.append(chunk)\n11 }\n

\n\n\n\n

\nCreate Local Embeddings Vectors From Local Text Files With OpenAI GPT APIs

\n\n

 1 func readList(_ input: String) -> [Float] {\n 2     return input.split(separator: \",\\n\").compactMap {\n 3         Float($0.trimmingCharacters(in: .whitespaces))\n 4     }\n 5 }\n 6 \n 7 let fileManager = FileManager.default\n 8 let currentDirectoryURL = URL(fileURLWithPath: fileManager.currentDirectoryPath)\n 9 let dataDirectoryURL = currentDirectoryURL.appendingPathComponent(\"data\")\n10 \n11 // Top level code expression to process all *.txt files in the data/ directory:\n12 \n13 do {\n14     let directoryContents = try fileManager.contentsOfDirectory(at: dataDirectoryURL\\\n15 , includingPropertiesForKeys: nil)\n16     let txtFiles = directoryContents.filter { $0.pathExtension == \"txt\" }\n17     for txtFile in txtFiles {\n18         let content = try String(contentsOf: txtFile)\n19         let chnks = segmentTextIntoChunks(text: content.plainText(),\n20                                           max_chunk_size: 100)\n21         for chunk in chnks {\n22             let embedding = embeddings(someText: chunk)\n23             if embedding.count > 0 {\n24                 addEmbedding(embedding)\n25                 addChunk(chunk)\n26             }\n27         }\n28     }\n29 } catch {\n30 }\n31        \n32 func segmentTextIntoSentences(text: String) -> [String] {\n33     let tokenizer = NLTokenizer(unit: .sentence)\n34     tokenizer.string = text\n35     let sentences = tokenizer.tokens(for: text.startIndex..<text.endIndex).map {\n36        token -> String in\n37          return String(text[token.lowerBound..<token.upperBound])\n38     }\n39     return sentences\n40 }\n41 \n42 func segmentTextIntoChunks(text: String, max_chunk_size: Int) -> [String] {\n43     let sentences = segmentTextIntoSentences(text: text)\n44     var chunks: Array<String> = Array()\n45     var currentChunk = \"\"\n46     var currentChunkSize = 0\n47     for sentence in sentences {\n48         if currentChunkSize + sentence.count < max_chunk_size {\n49             currentChunk += sentence\n50             currentChunkSize += sentence.count\n51         } else {\n52             chunks.append(currentChunk)\n53             currentChunk = sentence\n54             currentChunkSize = sentence.count\n55         }\n56     }\n57     return chunks\n58 }\n

\n\n\n\n

\nUsing Local Embeddings Vector Database With OpenAI GPT APIs

\n\n

We use the OpenAI QA API using gpt-4o-mini model (reformatted to fit the page width):

\n\n

 1 let openAiQaHost = \"https://api.openai.com/v1/chat/completions\"\n 2 \n 3 func openAiQaHelper(body: String)  -> String {\n 4     var ret = \"\"\n 5     var content = \"{}\"\n 6     let requestUrl = URL(string: openAiQaHost)!\n 7     var request = URLRequest(url: requestUrl)\n 8     request.httpMethod = \"POST\"\n 9     request.httpBody = body.data(using: String.Encoding.utf8);\n10     request.setValue(\"application/json\", forHTTPHeaderField: \"Content-Type\")\n11     request.setValue(\"Bearer \" + openai_key, forHTTPHeaderField: \"Authorization\")\n12     let task = URLSession.shared.dataTask(with: request) { (data, response, error) in\n13         if let error = error {\n14             print(\"-->> Error accessing OpenAI servers: \\(error)\")\n15             return\n16         }\n17         if let data = data, let s = String(data: data, encoding: .utf8) {\n18             content = s\n19             CFRunLoopStop(CFRunLoopGetMain())\n20         }\n21     }\n22     task.resume()\n23     CFRunLoopRun()\n24     let c = String(content)\n25     //print(\"DEBUG response c:\", c)\n26     // pull returned content for string instead of using a\n27     // JSON parser:\n28     let i1 = c.range(of: \"\\\"content\\\":\")\n29     if let r1 = i1 {\n30         let i2 = c.range(of: \"\\\"}\")\n31         if let r2 = i2 {\n32             ret = String(\n33                     String(\n34                       String(c[r1.lowerBound..<r2.lowerBound])\n35                         .dropFirst(11)))\n36         }\n37     }\n38     return ret\n39 }\n40 \n41 func questionAnswering(context: String, question: String) -> String {\n42     let body = \"{ \\\"model\\\": \\\"gpt-3.5-turbo\\\", \\\"messages\\\": [ {\\\"role\\\": \\\"system\\\\\n43 \", \\\"content\\\": \\\"\" +\n44       context + \"\\\"}, {\\\"role\\\": \\\"user\\\", \\\"content\\\": \\\"\" + question + \"\\\"}]}\"\n45 \n46     //print(\"DEBUG body:\", body)\n47     \n48     let answer = openAiQaHelper(body: body)\n49     if let i1 = answer.range(of: \"\\\"content\\\":\") {\n50         // variable answer is a string containing JSON. We want to extract the value\\\n51  of the \"content\" key and we do so without using a JSON parser.\n52         return String(answer[answer.startIndex..<i1.lowerBound])\n53     }\n54     return answer\n55 }\n56 \n57 //  Top level query interface:\n58 \n59 func query(_ query: String) -> String {\n60     let queryEmbedding = embeddings(someText: query)\n61     var contextText = \"\"\n62     for i in 0..<embeddingsStore.count {\n63         let dotProductResult = dotProduct(queryEmbedding, embeddingsStore[i])\n64         if dotProductResult > 0.8 {\n65             contextText.append(chunks[i])\n66             contextText.append(\" \")\n67         }\n68     }\n69     //print(\"\\n\\n+++++++ contextText = \\(contextText)\\n\\n\")\n70     let answer = questionAnswering(context: contextText, question: query)\n71     //print(\"* * debug: query: \", query)\n72     //print(\"* * debug: answer:\", answer)\n73     return answer\n74 \n75 }\n76 \n77 print(query(\"What is the history of chemistry?\"))\n78 print(query(\"What is the definition of sports?\"))\n79 print(query(\"What is the microeconomics?\"))\n

\n\n\n\n

The output for these three questions looks like:

\n\n

 1 The history of chemistry dates back to ancient times when people began to manipulate\\\n 2  materials to produce useful products. The ancient Egyptians were skilled in metallu\\\n 3 rgy and used various chemicals to embalm bodies. The Greeks were interested in theor\\\n 4 ies of matter and sought to understand the nature of substances.\\n\\nDuring the Middl\\\n 5 e Ages, alchemy became popular, with alchemists seeking to transform base metals int\\\n 6 o gold and searching for an elixir of life. While alchemy was considered a pseudosci\\\n 7 ence, it did lead to important discoveries such as the distillation of alcohol and t\\\n 8 he discovery of various acids.\\n\\nThe Scientific Revolution of the 17th century brou\\\n 9 ght about significant changes in chemistry. The work of Robert Boyle, Antoine Lavois\\\n10 ier, and others laid the foundation for modern chemistry. Lavoisier is considered th\\\n11 e father of modern chemistry for his work in establishing the law of conservation of\\\n12  mass, which states that matter cannot be created or destroyed.\\n\\nThe 19th century \\\n13 saw the development of organic chemistry, as scientists sought to understand the che\\\n14 mistry of carbon-based compounds, which make up many biological molecules. The 20th \\\n15 century brought about significant advances in analytical chemistry, as well as the d\\\n16 evelopment of quantum mechanics and the discovery of the structure of DNA, which rev\\\n17 olutionized the field of biochemistry.\\n\\nToday, chemistry plays a critical role in \\\n18 fields such as medicine, agriculture, materials science, and environmental science.\n19 \n20 \n21 Sports can be defined as activities involving physical athleticism, physical dexteri\\\n22 ty, and governed by rules to ensure fair competition and consistent adjudication of \\\n23 the winner. The term \\\"sport\\\" originally meant leisure, but it now primarily refers\\\n24  to physical activities that involve competition at various levels of skill and prof\\\n25 iciency. Some organizations also include all physical activity and exercise in the d\\\n26 efinition of sport.\n27 \n28 \n29 Microeconomics is a branch of economics that focuses on the behavior and decision-ma\\\n30 king of individual units within an economy, such as households, firms, and industrie\\\n31 s. It examines how these units interact in various markets to determine the prices o\\\n32 f goods and services and how resources are allocated efficiently. Microeconomics als\\\n33 o considers the role of government policies and regulations in influencing these int\\\n34 eractions and outcomes. Topics studied in microeconomics include supply and demand, \\\n35 market structures, consumer behavior, production and cost analysis, and welfare anal\\\n36 ysis.\n

\n\n\n\n

\nWrap Up for Using Local Embeddings Vector Database to Enhance the Use of GPT3 APIs With Local Documents

\n\n

As I write this in early April 2023, I have been working almost exclusively with OpenAI APIs for the last year and using the Python libraries for LangChain and LlamaIndex for the last three months.

\n\n

I started writing the examples in this chapter for my own use, implementing a tiny subset of the LangChain and LlamaIndex libraries in Swift in order to write efficient command line utilities for creating local embedding vector data stores and for interactive chat using my own data.

\n\n

By writing about my “scratching my own itch” command line experiments here I hope that I get pull requests for https://github.com/mark-watson/Docs_QA_Swift from readers who are interested in helping to extend this code with new functionality.

\n\n\n

\nPart 4: Knowledge Representation and Data Acquisition

\n\n

In this part we cover:

\n\n

Introduction to the semantic web and linked data
A general discussion of Knowledge Representation
Create Knowledge Graphs from text input
Knowledge Graph Explorer application

\n\n\n

\nLinked Data and the Semantic Web

\n\n

Tim Berners Lee, James Hendler, and Ora Lassila wrote in 2001 an article for Scientific American where they introduced the term Semantic Web. Here I do not capitalize semantic web and use the similar term linked data somewhat interchangeably with semantic web.

\n\n

In the same way that the web allows links between related web pages, linked data supports linking associated data on the web together. I view linked data as a relatively simple way to specify relationships between data sources on the web while the semantic web has a much larger vision: the semantic web has the potential to be the entirety of human knowledge represented as data on the web in a form that software agents can work with to answer questions, perform research, and to infer new data from existing data.

\n\n

While the “web” describes information for human readers, the semantic web is meant to provide structured data for ingestion by software agents. This distinction will be clear as we compare WikiPedia, made for human readers, with DBPedia which uses the info boxes on WikiPedia topics to automatically extract RDF data describing WikiPedia topics. Let’s look at the WikiPedia topic for the town I live in Sedona, Arizona, and show how the info box on the English version of the WikiPedia topic page for Sedona https://en.wikipedia.org/wiki/Sedona,_Arizona maps to the DBPedia page http://dbpedia.org/page/Sedona,_Arizona. Please open both of these WikiPedia and DBPedia URIs in two browser tabs and keep them open for reference.

\n\n

I assume that the format of the WikiPedia page is familiar so let’s look at the DBPedia page for Sedona that in human readble form shows the RDF statements with Sedona Arizona as the subject. RDF is used to model and represent data. RDF is defined by three values so an instance of an RDF statement is called a triple with three parts:

\n\n

subject: a URI (also referred to as a “Resource”)
property: a URI (also referred to as a “Resource”)
value: a URI (also referred to as a “Resource”) or a literal value (like a string or a number with optional units)

\n\n

The subject for each Sedona related triple is the above URI for the DBPedia human readable page. The subject and property references in an RDF triple will almost always be a URI that can ground an entity to information on the web. The human readable page for Sedona lists several properties and the values of these properties. One of the properties is “dbo:areaCode” where “dbo” is a name space reference (in this case for a DatatypeProperty).

\n\n

The following two figures show an abstract representation of linked data and then a sample of linked data with actual web URIs for resources and properties:

\n\n\n

\n\n\n\n

\"Concrete — Concrete example using RDF seen in last chapter showing the RDF representation with 2 Resources, 2 literal values, and 3 Properties

\n\n\n

We will use the SPARQL query language (SPARQL for RDF data is similar to SQL for relational database queries). Let’s look at an example using the RDF in the last figure:

\n\n

1     \"select ?v where { <http://markwatson.com/index.rdf#Sun_ONE>\n2                        <http://www.ontoweb.org/ontology/1#booktitle>\n3                        ?v }\n

\n\n\n\n

This query should return the result “Sun ONE Services - J2EE”. If you wanted to query for all URI resources that are books with the literal value of their titles, then you can use:

\n\n

1     \"select ?s ?v where { ?s\n2                           <http://www.ontoweb.org/ontology/1#booktitle>\n3                           ?v }\n

\n\n\n\n

Note that ?s and ?v are arbitrary query variable names, here standing for “subject” and “value”. You can use more descriptive variable names like:

\n\n

1     \"select ?bookURI ?bookTitle where \n2         { ?bookURI\n3           <http://www.ontoweb.org/ontology/1#booktitle>\n4           ?bookTitle }\n

\n\n\n\n

We will be diving a little deeper into RDF examples in the next chapter when we write a tool for using RDF data from DBPedia to find information about entities (e.g., people, places, organizations) and the relationships between entities. For now I want you to understand the idea of RDF statements represented as triples, that web URIs represent things, properties, and sometimes values, and that URIs can be followed manually (often called “dereferencing”) to see what they reference in human readable form.

\n\n

\nUnderstanding the Resource Description Framework (RDF)

\n\n

Text data on the web has some structure in the form of HTML elements like headers, page titles, anchor links, etc. but this structure is too imprecise for general use by software agents. RDF is a method for encoding structured data in a more precise way.

\n\n

RDF specifies graph structures and can be serialized for storage or for service calls in XML, Turtle, N3, and other formats. I like the Turtle format and suggest that you pause reading this book for a few minutes and look at this World Wide Web Consortium Turtle RDF primer at https://www.w3.org/2007/02/turtle/primer/.

\n\n

\nFrequently Used Resource Namespaces

\n\n

The following standard namespaces are frequently used:

\n\n

RDF https://www.w3.org/TR/rdf-syntax-grammar/\n
RDFS https://www.w3.org/TR/rdf-schema/\n
OWL http://www.w3.org/2002/07/owl#\n
XSD http://www.w3.org/2001/XMLSchema#\n
FOAF http://xmlns.com/foaf/0.1/\n
SKOS http://www.w3.org/2004/02/skos/core#\n
DOAP http://usefulinc.com/ns/doap#\n
DC http://purl.org/dc/elements/1.1/\n
DCTERMS http://purl.org/dc/terms/\n
VOID http://rdfs.org/ns/void#\n

\n\n

Let’s look into the Friend of a Friend (FOAF) namespace. Click on the above link for FOAF http://xmlns.com/foaf/0.1/ and find the definitions for the FOAF Core:

\n\n

 1     Agent\n 2     Person\n 3     name\n 4     title\n 5     img\n 6     depiction (depicts)\n 7     familyName\n 8     givenName\n 9     knows\n10     based_near\n11     age\n12     made (maker)\n13     primaryTopic (primaryTopicOf)\n14     Project\n15     Organization\n16     Group\n17     member\n18     Document\n19     Image\n

\n\n\n\n

and for the Social Web:

\n\n

 1 mbox\n 2 homepage\n 3 weblog\n 4 openid\n 5 jabberID\n 6 mbox_sha1sum\n 7 interest\n 8 topic_interest\n 9 topic (page)\n10 workplaceHomepage\n11 workInfoHomepage\n12 schoolHomepage\n13 publications\n14 currentProject\n15 pastProject\n16 account\n17 OnlineAccount\n18 accountName\n19 accountServiceHomepage\n20 PersonalProfileDocument\n21 tipjar\n22 sha1\n23 thumbnail\n24 logo\n

\n\n\n\n

You now have seen a few common Schemas for RDF data. Another Schema that is widely used for annotating web sites that we won’t need for our examples here, is schema.org.

\n\n

\nUnderstanding the SPARQL Query Language

\n\n

For the purposes of the material in this book, the two sample SPARQL queries here are sufficient for you to get started using my SPARQL library https://github.com/mark-watson/SparqlQuery_swift with arbitrary RDF data sources and simple queries.

\n\n\n

\"My — My Swift SPARQL library open in Xcode

\n\n\n

The Apache Foundation has a good introduction to SPARQL that I refer you to for more information.

\n\n

\nSemantic Web and Linked Data Wrap Up

\n\n

In the next chapter we will use natural language processing to extract structured information from raw text from SPARQL queries. We will be using my Swift SPARQL library https://github.com/mark-watson/SparqlQuery_swift as well as two pre-trained CoreML deep learning models.

\n\n\n

\nExample Application: iOS and macOS Versions of my KnowledgeBookNavigator

\n\n

I used many of the techniques discussed in this book, the Swift language, and the SwiftUI user interface framework to develop Swift version of my Knowledge Graph Navigator application for macOS. I originally wrote this as an example program in Common Lisp for another book project.

\n\n

The GitHub repository for the KGN example is https://github.com/mark-watson/KGN. I copied the code from my stand-alone Swift libraries to this example to make it self contained. The easiest way to browse the source code is to open this project in Xcode.

\n\n

I submitted the KGN app that we discuss in this chapter to Apple’s store and is available as a macOS app. If you load this project into Xcode, you can also build and run the iOS and iPadOS targets.

\n\n

You will need to have read through the last chapter on semantic web and linked data technologies to understand this example because quite a lot of the code has embedded SPARQL queries to get information from DBPedia.org.

\n\n

The other major part of this app is a slightly modified version of Apple’s question answering (QA) example using the BERT model in CoreML. Apple’s code is in the subdirectory AppleBERT. Please read the README file for this project and follow the directions for downloading and using Apple’s model and vocabulary file.

\n\n

\nScreen Shots of macOS Application

\n\n

In the first screenshot seen below, I had entered query text that included “Steve Jobs” and the popup list selector is used to let the user select which “Steve Jobs” entity from DBPedia that they want to use.

\n\n\n

\n\n\n\n

\n\n\n

The previous screenshot shows the results to the query displayed as English text.

\n\n

Notice the app prompt “Behind the scenes SPARQL queries” near the bottom of the app window. If you click on this field then the SPARQL queries used to answer the question are shown, as on the next screenshot:

\n\n\n

\nApplication Code Listings

\n\n

I will list some of the code for this example application and I suggest that you, dear reader, also open this project in Xcode in order to navigate the sample code and more carefully read through it.

\n\n

\nSPARQL

\n\n

I introduced you to the use of SPARQL in the last chapter. This library can be used by adding a reference to the Project.swift file for this project. You can also clone the GitHub repository https://github.com/mark-watson/Nlp_swift to have the source code for local viewing and modification and I have copied the code into the KGN project.

\n\n

The file SparqlQuery.swift is shown here:

\n\n

 1 import Foundation\n 2 \n 3 public func sparqlDbPedia(query: String) -> Array<Dictionary<String,String>> {\n 4     return SparqlEndpointHelpter(query: query,\n 5         endPointUri: \"https://dbpedia.org/sparql?query=\") }\n 6 \n 7 public func sparqlWikidata(query: String) -> Array<Dictionary<String,String>> {\n 8     return SparqlEndpointHelpter(query: query,\n 9         endPointUri:\n10           \"https://query.wikidata.org/bigdata/namespace/wdq/sparql?query=\") }\n11 \n12 public func SparqlEndpointHelpter(query: String,\n13                                   endPointUri: String) ->\n14                             Array<Dictionary<String,String>> {\n15     var ret = Set<Dictionary<String,String>>();\n16     var content = \"{}\"\n17 \n18     let maybeString = cacheLookupQuery7(key: query)\n19     if maybeString?.count ?? 0 > 0 {\n20         content = maybeString ?? \"\"\n21     } else {\n22         let requestUrl = URL(string: String(endPointUri + query.addingPercentEncodin\\\n23 g(withAllowedCharacters:\n24           .urlHostAllowed)!) + \"&format=json\")!\n25         do { content = try String(contentsOf: requestUrl) }\n26           catch let error { print(error) }\n27     }\n28     let json = try? JSONSerialization.jsonObject(with: Data(content.utf8),\n29                                                  options: [])\n30     if let json2 = json as! Optional<Dictionary<String, Any?>> {\n31         if let head = json2[\"head\"] as? Dictionary<String, Any> {\n32             if let xvars = head[\"vars\"] as! NSArray? {\n33                 if let results = json2[\"results\"] as? Dictionary<String, Any> {\n34                     if let bindings = results[\"bindings\"] as! NSArray? {\n35                         if bindings.count > 0 {\n36                             for i in 0...(bindings.count-1) {\n37                                 if let first_binding =\n38                                 bindings[i] as? Dictionary<String,\n39                                 Dictionary<String,String>> {\n40                                     var ret2 = Dictionary<String,String>();\n41                                     for key in xvars {\n42                                         let key2 : String = key as! String\n43                                         if let vals = (first_binding[key2]) {\n44                                             let vv : String = vals[\"value\"] ?? \"err2\"\n45                                             ret2[key2] = vv } }\n46                                     if ret2.count > 0 {\n47                                         ret.insert(ret2)\n48                                     }}}}}}}}}\n49     return Array(ret) }\n

\n\n\n\n

The file QueryCache.swift contains code written by Khoa Pham (MIT License) that can be found in the GitHub repository https://github.com/onmyway133/EasyStash. This file is used to cache SPARQL queries and the results. In testing this application I noticed that there were many repeated queries to DBPedia so I decided to cache results. Here is the simple API I added on top of Khoa Pham’s code:

\n\n

 1 //  Created by khoa on 27/05/2019.\n 2 //  Copyright © 2019 Khoa Pham. All rights reserved. MIT License.\n 3 //  https://github.com/onmyway133/EasyStash\n 4 //\n 5 \n 6 import Foundation\n 7 \n 8 //      Mark's simple wrapper:\n 9 \n10 var storage: Storage? = nil\n11 \n12 public func cacheStoreQuery(key: String, value: String) {\n13     do { try storage?.save(object: value, forKey: key) } catch {}\n14 }\n15 public func cacheLookupQuery7(key: String) -> String? {\n16     // optional DEBUG code: clear cache\n17     //do { try storage?.removeAll() } catch { print(\"ERROR CLEARING CACHE\") }\n18     do {\n19         return try storage?.load(forKey: key, as: String.self)\n20     } catch { return \"\" }\n21 }\n22 \n23 // remaining code not shown for brevity.\n

\n\n\n\n

The code in file GenerateSparql.swift is used to generate queries for DBPedia. The line-wrapping for embedded SPARQL queries in the next code section is difficult to read so you may want to open the source file in Xcode. Please note that the KGN application prints out the SPARQL queries used to fetch information from DBPedia. The embedded SPARQL query templates used here have variable slots that filled in at runtime to customize the queries.

\n\n

  1 //\n  2 //  GenerateSparql.swift\n  3 //  KGNbeta1\n  4 //\n  5 //  Created by Mark Watson on 2/28/20.\n  6 //  Copyright © 2021 Mark Watson. All rights reserved.\n  7 //\n  8 \n  9 import Foundation\n 10 \n 11 public func uri_to_display_text(uri: String)\n 12                                      -> String {\n 13     return uri.replacingOccurrences(of: \"http://dbpedia.org/resource/Category/\",\n 14         with: \"\").\n 15       replacingOccurrences(of: \"http://dbpedia.org/resource/\",\n 16         with: \"\").\n 17          replacingOccurrences(of: \"_\", with: \" \")\n 18 }\n 19 \n 20 public func get_SPARQL_for_finding_URIs_for_PERSON_NAME(nameString: String)\n 21                                               -> String {\n 22     return\n 23         \"# SPARQL to find all URIs for name: \" +\n 24         nameString + \"\\nSELECT DISTINCT ?person_uri ?comment {\\n\" +\n 25         \"  ?person_uri <http://xmlns.com/foaf/0.1/name> \\\"\" +\n 26         nameString + \"\\\"@en .\\n\" +\n 27         \"  OPTIONAL { ?person_uri <http://www.w3.org/2000/01/rdf-schema#comment>\\n\" +\n 28         \"     ?comment . FILTER (lang(?comment) = 'en') } .\\n\" +\n 29         \"} LIMIT 10\\n\"\n 30 }\n 31 \n 32 public func get_SPARQL_for_PERSON_URI(aURI: String) -> String {\n 33     return\n 34         \"# <\" + aURI + \">\\nSELECT DISTINCT ?comment (GROUP_CONCAT(DISTINCT ?birthpla\\\n 35 ce; SEPARATOR=' | ') AS ?birthplace)\\n  (GROUP_CONCAT(DISTINCT ?almamater; SEPARATOR\\\n 36 =' | ') AS ?almamater) (GROUP_CONCAT(DISTINCT ?spouse; SEPARATOR=' | ') AS ?spouse) \\\n 37 {\\n\" +\n 38         \"  <\" + aURI + \"> <http://www.w3.org/2000/01/rdf-schema#comment>  ?comment .\\\n 39  FILTER  (lang(?comment) = 'en') .\\n\" +\n 40         \"  OPTIONAL { <\" + aURI + \"> <http://dbpedia.org/ontology/birthPlace> ?birth\\\n 41 place } .\\n\" +\n 42         \"  OPTIONAL { <\" + aURI + \"> <http://dbpedia.org/ontology/almaMater> ?almama\\\n 43 ter } .\\n\" +\n 44         \"  OPTIONAL { <\" + aURI + \"> <http://dbpedia.org/ontology/spouse> ?spouse } \\\n 45 .\\n\" +\n 46         \"} LIMIT 5\\n\"\n 47 }\n 48 \n 49 public func get_display_text_for_PERSON_URI(personURI: String) -> [String] {\n 50     var ret: String = \"\\(uri_to_display_text(uri: personURI))\\n\\n\"\n 51     let person_details_sparql = get_SPARQL_for_PERSON_URI(aURI: personURI)\n 52     let person_details = sparqlDbPedia(query: person_details_sparql)\n 53     \n 54     for pd in person_details {\n 55         //let comment = pd[\"comment\"]\n 56         ret.append(\"\\(pd[\"comment\"] ?? \"\")\\n\\n\")\n 57         let subject_uris = pd[\"subject_uris\"]\n 58         let uri_list: [String] = subject_uris?.components(separatedBy: \" | \") ?? []\n 59         //ret.append(\"<ul>\\n\")\n 60         for u in uri_list {\n 61             let subject = uri_to_display_text(uri: u)\n 62             ret.append(\"\\(subject)\\n\") }\n 63         //ret.append(\"</ul>\\n\")\n 64         if let spouse = pd[\"spouse\"] {\n 65             if spouse.count > 0 {\n 66                 ret.append(\"Spouse: \\(uri_to_display_text(uri: spouse))\\n\") } }\n 67         if let almamater = pd[\"almamater\"] {\n 68             if almamater.count > 0 {\n 69                 ret.append(\"Almamater: \\(uri_to_display_text(uri: almamater))\\n\") } }\n 70         if let birthplace = pd[\"birthplace\"] {\n 71             if birthplace.count > 0 {\n 72                 ret.append(\"Birthplace: \\(uri_to_display_text(uri: birthplace))\\n\") \\\n 73 } }\n 74     }\n 75     return [\"# SPARQL for a specific person:\\n\" + person_details_sparql, ret]\n 76 }\n 77 \n 78 //     \"  ?place_uri <http://xmlns.com/foaf/0.1/name> \\\"\" + placeString + \"\\\"@en .\\n\\\n 79 \" +\n 80 \n 81 public func get_SPARQL_for_finding_URIs_for_PLACE_NAME(placeString: String)\n 82                                                -> String {\n 83     return\n 84         \"# \" + placeString + \"\\nSELECT DISTINCT ?place_uri ?comment {\\n\" +\n 85         \"  ?place_uri rdfs:label \\\"\" + placeString + \"\\\"@en .\\n\" +\n 86         \"  ?place_uri <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://sche\\\n 87 ma.org/Place> .\\n\" +\n 88         \"  OPTIONAL { ?place_uri <http://www.w3.org/2000/01/rdf-schema#comment>\\n\" +\n 89         \"     ?comment . FILTER (lang(?comment) = 'en') } .\\n\" +\n 90         \"} LIMIT 10\\n\"\n 91 }\n 92 \n 93 public func get_SPARQL_for_PLACE_URI(aURI: String) -> String {\n 94     return\n 95         \"# <\" + aURI + \">\\nSELECT DISTINCT ?comment (GROUP_CONCAT(DISTINCT ?subject_\\\n 96 uris; SEPARATOR=' | ') AS ?subject_uris) {\\n\" +\n 97         \"  <\" + aURI + \"> <http://www.w3.org/2000/01/rdf-schema#comment>  ?comment .\\\n 98  FILTER  (lang(?comment) = 'en') .\\n\" +\n 99         \"  OPTIONAL { <\" + aURI + \"> <http://purl.org/dc/terms/subject> ?subject_uri\\\n100 s } .\\n\" +\n101         \"} LIMIT 5\\n\"\n102 }\n103 \n104 public func get_HTML_for_place_URI(placeURI: String) -> String {\n105     var ret: String = \"<h2>\" + placeURI + \"</h2>\\n\"\n106     let place_details_sparql = get_SPARQL_for_PLACE_URI(aURI: placeURI)\n107     let place_details = sparqlDbPedia(query: place_details_sparql)\n108     \n109     for pd in place_details {\n110         //let comment = pd[\"comment\"]\n111         ret.append(\"<p><strong>\\(pd[\"comment\"] ?? \"\")</strong></p>\\n\")\n112         let subject_uris = pd[\"subject_uris\"]\n113         let uri_list: [String] = subject_uris?.components(separatedBy: \" | \") ?? []\n114         ret.append(\"<ul>\\n\")\n115         for u in uri_list {\n116             let subject = u.replacingOccurrences(of: \"http://dbpedia.org/resource/Ca\\\n117 tegory:\", with: \"\").replacingOccurrences(of: \"_\", with: \" \").replacingOccurrences(of\\\n118 : \"-\", with: \" \")\n119             ret.append(\"  <li>\\(subject)</li>\\n\")\n120         }\n121         ret.append(\"</ul>\\n\")\n122     }\n123     return ret\n124 }\n125 \n126 public func get_SPARQL_for_finding_URIs_for_ORGANIZATION_NAME(orgString: String) -> \\\n127 String {\n128     return\n129         \"# \" + orgString + \"\\nSELECT DISTINCT ?org_uri ?comment {\\n\" +\n130         \"  ?org_uri rdfs:label \\\"\" + orgString + \"\\\"@en .\\n\" +\n131         \"  ?org_uri <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema\\\n132 .org/Organization> .\\n\" +\n133         \"  OPTIONAL { ?org_uri <http://www.w3.org/2000/01/rdf-schema#comment>\\n\" +\n134         \"     ?comment . FILTER (lang(?comment) = 'en') } .\\n\" +\n135         \"} LIMIT 2\\n\"\n136 }\n

\n\n\n\n

The file AppSparql contains more utility functions for getting entity and relationship data from DBPedia:

\n\n

  1 //  AppSparql.swift\n  2 //  Created by ML Watson on 7/18/21.\n  3 \n  4 import Foundation\n  5 \n  6 let detailSparql = \"\"\"\n  7 PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n  8 select ?entity ?label ?description ?comment where {\n  9     ?entity rdfs:label \"<name>\"@en .\n 10     ?entity schema:description ?description . filter (lang(?description) = 'en') . f\\\n 11 ilter(!regex(?description,\"Wikimedia disambiguation page\")) .\n 12  } limit 5000\n 13 \"\"\"\n 14 \n 15 let personSparql = \"\"\"\n 16   select ?uri ?comment {\n 17       ?uri <http://xmlns.com/foaf/0.1/name> \"<name>\"@en .\n 18       ?uri <http://www.w3.org/2000/01/rdf-schema#comment>  ?comment .\n 19           FILTER  (lang(?comment) = 'en') .\n 20   }\n 21 \"\"\"\n 22 \n 23 \n 24 let personDetailSparql = \"\"\"\n 25 SELECT DISTINCT ?label ?comment\n 26                      \n 27      (GROUP_CONCAT (DISTINCT ?birthplace; SEPARATOR=' | ') AS ?birthplace)\n 28      (GROUP_CONCAT (DISTINCT ?almamater; SEPARATOR=' | ') AS ?almamater)\n 29      (GROUP_CONCAT (DISTINCT ?spouse; SEPARATOR=' | ') AS ?spouse) {\n 30        <name> <http://www.w3.org/2000/01/rdf-schema#comment>  ?comment .\n 31        FILTER  (lang(?comment) = 'en') .\n 32      OPTIONAL { <name> <http://dbpedia.org/ontology/birthPlace> ?birthplace } .\n 33      OPTIONAL { <name> <http://dbpedia.org/ontology/almaMater> ?almamater } .\n 34      OPTIONAL { <name> <http://dbpedia.org/ontology/spouse> ?spouse } .\n 35      OPTIONAL { <name>  <http://www.w3.org/2000/01/rdf-schema#label> ?label .\n 36         FILTER  (lang(?label) = 'en') }\n 37 } LIMIT 10\n 38 \"\"\"\n 39 \n 40 let placeSparql = \"\"\"\n 41 SELECT DISTINCT ?uri ?comment WHERE {\n 42    ?uri rdfs:label \"<name>\"@en .\n 43    ?uri <http://www.w3.org/2000/01/rdf-schema#comment>  ?comment .\n 44    FILTER (lang(?comment) = 'en') .\n 45    ?place <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Place\\\n 46 > .\n 47 } LIMIT 80\n 48 \"\"\"\n 49 \n 50 let organizationSparql = \"\"\"\n 51 SELECT DISTINCT ?uri ?comment WHERE {\n 52    ?uri rdfs:label \"<name>\"@en .\n 53    ?uri <http://www.w3.org/2000/01/rdf-schema#comment>  ?comment .\n 54    FILTER (lang(?comment) = 'en') .\n 55    ?uri <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Organiz\\\n 56 ation> .\n 57 } LIMIT 80\n 58 \"\"\"\n 59 \n 60 func entityDetail(name: String) -> [Dictionary<String,String>] {\n 61     var ret: [Dictionary<String,String>] = []\n 62     let sparql = detailSparql.replacingOccurrences(of: \"<name>\", with: name)\n 63     print(sparql)\n 64     let r = sparqlDbPedia(query: sparql)\n 65     r.forEach { result in\n 66         print(result)\n 67         ret.append(result)\n 68     }\n 69     return ret\n 70 }\n 71 \n 72 func personDetail(name: String) -> [Dictionary<String,String>] {\n 73     var ret: [Dictionary<String,String>] = []\n 74     let sparql = personSparql.replacingOccurrences(of: \"<name>\", with: name)\n 75     print(sparql)\n 76     let r = sparqlDbPedia(query: sparql)\n 77     r.forEach { result in\n 78         print(result)\n 79         ret.append(result)\n 80     }\n 81     return ret\n 82 }\n 83 \n 84 func placeDetail(name: String) -> [Dictionary<String,String>] {\n 85     var ret: [Dictionary<String,String>] = []\n 86     let sparql = placeSparql.replacingOccurrences(of: \"<name>\", with: name)\n 87     print(sparql)\n 88     let r = sparqlDbPedia(query: sparql)\n 89     r.forEach { result in\n 90         print(result)\n 91         ret.append(result)\n 92     }\n 93     return ret\n 94 }\n 95 \n 96 func organizationDetail(name: String) -> [Dictionary<String,String>] {\n 97     var ret: [Dictionary<String,String>] = []\n 98     let sparql = organizationSparql.replacingOccurrences(of: \"<name>\", with: name)\n 99     print(sparql)\n100     let r = sparqlDbPedia(query: sparql)\n101     r.forEach { result in\n102         print(result)\n103         ret.append(result)\n104     }\n105     return ret\n106 }\n107 \n108 public func processEntities(inputString: String) -> [(name: String, type: String, ur\\\n109 i: String, comment: String)] {\n110     let entities = getEntities(text: inputString)\n111     var augmentedEntities: [(name: String, type: String, uri: String, comment: Strin\\\n112 g)] = []\n113     for (entityName, entityType) in entities {\n114         print(\"** entityName:\", entityName, \"entityType:\", entityType)\n115         if entityType == \"PersonalName\" {\n116             let data = personDetail(name: entityName)\n117             for d in data {\n118                 augmentedEntities.append((name: entityName, type: entityType,\n119                     uri: \"<\" + d[\"uri\"]! + \">\", comment: \"<\" + d[\"comment\"]! + \">\"))\n120             }\n121         }\n122         if entityType == \"OrganizationName\" {\n123             let data = organizationDetail(name: entityName)\n124             for d in data {\n125                 augmentedEntities.append((name: entityName, type: entityType,\n126                     uri: \"<\" + d[\"uri\"]! + \">\", comment: \"<\" + d[\"comment\"]! + \">\"))\n127             }\n128         }\n129         if entityType == \"PlaceName\" {\n130             let data = placeDetail(name: entityName)\n131             for d in data {\n132                 augmentedEntities.append((name: entityName, type: entityType,\n133                     uri: \"<\" + d[\"uri\"]! + \">\", comment: \"<\" + d[\"comment\"]! + \">\"))\n134             }\n135         }\n136     }\n137     return augmentedEntities\n138 }\n139 \n140 \n141 extension Array where Element: Hashable {\n142     func uniqueValuesHelper() -> [Element] {\n143         var addedDict = [Element: Bool]()\n144         return filter { addedDict.updateValue(true, forKey: $0) == nil }\n145     }\n146     mutating func uniqueValues() {\n147         self = self.uniqueValuesHelper()\n148     }\n149 }\n150 \n151 \n152 func getAllRelationships(inputString: String) -> [String] {\n153     let augmentedEntities = processEntities(inputString: inputString)\n154     var relationshipTriples: [String] = []\n155     for ae1 in augmentedEntities {\n156         for ae2 in augmentedEntities {\n157             if ae1 != ae2 {\n158                 let er1 = dbpediaGetRelationships(entity1Uri: ae1.uri,\n159                                                   entity2Uri: ae2.uri)\n160                 relationshipTriples.append(contentsOf: er1)\n161                 let er2 = dbpediaGetRelationships(entity1Uri: ae2.uri,\n162                                                   entity2Uri: ae1.uri)\n163                 relationshipTriples.append(contentsOf: er2)\n164             }\n165         }\n166     }\n167     relationshipTriples.uniqueValues()\n168     relationshipTriples.sort()\n169     return relationshipTriples\n170 }\n

\n\n\n\n

\nAppleBERT

\n\n

The files in the directory AppleBERT were copied from Apple’s example https://developer.apple.com/documentation/coreml/model_integration_samples/finding_answers_to_questions_in_a_text_document with a few changes to get returned results in a convenient format for this application. Apple’s BERT documentation is excellent and you should review it.

\n\n

\nRelationships

\n\n

The file Relationships.swift fetches relationship data for pairs of DBPedia entities. Note that the first SPARQL template has variable slots <e1> and <e2> that are replaced at runtime with URIs representing the entities that we are searching for relationships between these two entities:

\n\n

 1 // relationships between DBPedia entities\n 2 \n 3 let relSparql =  \"\"\"\n 4 SELECT DISTINCT ?p {<e1> ?p <e2> .FILTER (!regex(str(?p), 'wikiPage', 'i'))} LIMIT 5\n 5 \"\"\"\n 6 \n 7 public func dbpediaGetRelationships(entity1Uri: String, entity2Uri: String)\n 8                                       -> [String] {\n 9     var ret: [String] = []\n10     let sparql1 = relSparql.replacingOccurrences(of: \"<e1>\",\n11       with: entity1Uri).replacingOccurrences(of: \"<e2>\",\n12         with: entity2Uri)\n13     let r1 = sparqlDbPedia(query: sparql1)\n14     r1.forEach { result in\n15         if let relName = result[\"p\"] {\n16             let rdfStatement = entity1Uri + \" <\" + relName + \"> \" + entity2Uri + \" .\"\n17             print(rdfStatement)\n18             ret.append(rdfStatement)\n19         }\n20     }\n21     let sparql2 = relSparql.replacingOccurrences(of: \"<e1>\",\n22         with: entity2Uri).replacingOccurrences(of: \"<e2>\",\n23             with: entity1Uri)\n24     let r2 = sparqlDbPedia(query: sparql2)\n25     r2.forEach { result in\n26         if let relName = result[\"p\"] {\n27             let rdfStatement = entity2Uri + \" <\" + relName + \"> \" + entity1Uri + \" .\"\n28             print(rdfStatement)\n29             ret.append(rdfStatement)\n30         }\n31     }\n32     return Array(Set(ret))\n33 }\n34 \n35 public func uriToPrintName(_ uri: String) -> String {\n36     let slashIndex = uri.lastIndex(of: \"/\")\n37     if slashIndex == nil { return uri }\n38     var s = uri[slashIndex!...]\n39     s = s.dropFirst()\n40     if s.count > 0 { s.removeLast() }\n41     return String(s).replacingOccurrences(of: \"_\", with: \" \")\n42 }\n43 \n44 public func relationshipsoEnglish(rs: [String]) -> String {\n45     var lines: [String] = []\n46     for r in rs {\n47         let triples = r.split(separator: \" \", maxSplits: 3,\n48             omittingEmptySubsequences: true)\n49         if triples.count > 2 {\n50             lines.append(uriToPrintName(String(triples[0])) + \" \" +\n51               uriToPrintName(String(triples[1])) + \" \" +\n52                 uriToPrintName(String(triples[2])))\n53         } else {\n54             lines.append(r)\n55         }\n56     }\n57     let linesNoDuplicates = Set(lines)\n58     return linesNoDuplicates.joined(separator: \"\\n\")\n59 }\n

\n\n\n\n

\nNLP

\n\n

The file NlpWhiteboard provides high level NLP utility functions for the application:

\n\n

 1 //\n 2 //  NlpWhiteboard.swift\n 3 //  KGN\n 4 //\n 5 //  Copyright © 2021 Mark Watson. All rights reserved.\n 6 //\n 7 \n 8 public struct NlpWhiteboard {\n 9 \n10     var originalText: String = \"\"\n11     var people: [String] = []\n12     var places: [String] = []\n13     var organizations: [String] = []\n14     var sparql: String = \"\"\n15 \n16     init() { }\n17 \n18     mutating func set_text(originalText: String) {\n19         self.originalText = originalText\n20         let (people, places, organizations) = getAllEntities(text:  originalText)\n21         self.people = people; self.places = places; self.organizations = organizatio\\\n22 ns\n23     }\n24     \n25     mutating func query_to_choices(behindTheScenesSparqlText: inout String)\n26           -> [[[String]]] { // return inner: [comment, uri]\n27         var ret: Set<[[String]]> = []\n28         if people.count > 0 {\n29             for i in 0...(people.count - 1) {\n30                 self.sparql =\n31                   get_SPARQL_for_finding_URIs_for_PERSON_NAME(nameString: people[i])\n32                 behindTheScenesSparqlText += self.sparql\n33                 let results = sparqlDbPedia(query: self.sparql)\n34                 if results.count > 0 {\n35                     ret.insert( results.map { [($0[\"comment\"]\n36                                                 ?? \"\"),\n37                                                 ($0[\"person_uri\"] ?? \"\")] })\n38                 }\n39             }\n40         }\n41         if organizations.count > 0 {\n42             for i in 0...(organizations.count - 1) {\n43                 self.sparql = get_SPARQL_for_finding_URIs_for_ORGANIZATION_NAME(\n44                     orgString: organizations[i])\n45                 behindTheScenesSparqlText += self.sparql\n46                 let results = sparqlDbPedia(query: self.sparql)\n47                 if results.count > 0 {\n48                     ret.insert(results.map { [($0[\"comment\"] ??\n49                       \"\"), ($0[\"org_uri\"] ?? \"\")] })\n50                 }\n51             }\n52         }\n53         if places.count > 0 {\n54             for i in 0...(places.count - 1) {\n55                 self.sparql = get_SPARQL_for_finding_URIs_for_PLACE_NAME(\n56                     placeString: places[i])\n57                 behindTheScenesSparqlText += self.sparql\n58                 let results = sparqlDbPedia(query: self.sparql)\n59                 if results.count > 0 {\n60                     ret.insert( results.map { [($0[\"comment\"] ??\n61                       \"\"), ($0[\"place_uri\"] ?? \"\")] })\n62                 }\n63             }\n64         }\n65         //print(\"\\n\\n+++++++ ret:\\n\", ret, \"\\n\\n\")\n66         return Array(ret)\n67     }\n68 }\n

\n\n\n\n

The file NLPutils.swift provides lower level NLP utilities:

\n\n

  1 //  NLPutils.swift\n  2 //  KGN\n  3 //\n  4 //  Copyright © 2021 Mark Watson. All rights reserved.\n  5 //\n  6 \n  7 import Foundation\n  8 import NaturalLanguage\n  9 \n 10 public func getPersonDescription(personName: String) -> [String] {\n 11     let sparql = get_SPARQL_for_finding_URIs_for_PERSON_NAME(nameString: personName)\n 12     let results = sparqlDbPedia(query: sparql)\n 13     return [sparql, results.map {\n 14       ($0[\"comment\"] ?? $0[\"abstract\"] ?? \"\") }.joined(separator: \" . \")]\n 15 }\n 16 \n 17 \n 18 public func getPlaceDescription(placeName: String) -> [String] {\n 19     let sparql = get_SPARQL_for_finding_URIs_for_PLACE_NAME(placeString: placeName)\n 20     let results = sparqlDbPedia(query: sparql)\n 21     return [sparql, results.map { ($0[\"comment\"] ??\n 22         $0[\"abstract\"] ?? \"\") }.joined(separator: \" . \")]\n 23 }\n 24 \n 25 public func getOrganizationDescription(organizationName: String) -> [String] {\n 26     let sparql = get_SPARQL_for_finding_URIs_for_ORGANIZATION_NAME(\n 27         orgString: organizationName)\n 28     let results = sparqlDbPedia(query: sparql)\n 29     print(\"=== getOrganizationDescription results =\\n\", results)\n 30     return [sparql, results.map { ($0[\"comment\"] ?? $0[\"abstract\"] ?? \"\") }\n 31         .joined(separator: \" . \")]\n 32 }\n 33 \n 34 let tokenizer = NLTokenizer(unit: .word)\n 35 let tagger = NSLinguisticTagger(tagSchemes:[.tokenType, .language, .lexicalClass,\n 36   .nameType, .lemma], options: 0)\n 37 let options: NSLinguisticTagger.Options =\n 38     [.omitPunctuation, .omitWhitespace, .joinNames]\n 39 \n 40 let tokenizerOptions: NSLinguisticTagger.Options =\n 41     [.omitPunctuation, .omitWhitespace, .joinNames]\n 42 \n 43 public func getEntities(text: String) -> [(String, String)] {\n 44     var words: [(String, String)] = []\n 45     tagger.string = text\n 46     let range = NSRange(location: 0, length: text.utf16.count)\n 47     tagger.enumerateTags(in: range, unit: .word,\n 48         scheme: .nameType, options: options) { tag, tokenRange, stop in\n 49         let word = (text as NSString).substring(with: tokenRange)\n 50         let tagType = tag?.rawValue ?? \"unkown\"\n 51         if tagType != \"unkown\" && tagType != \"OtherWord\" {\n 52             words.append((word, tagType))\n 53         }\n 54     }\n 55     return words\n 56 }\n 57 \n 58 public func tokenizeText(text: String) -> [String] {\n 59     var tokens: [String] = []\n 60     tokenizer.string = text\n 61     tokenizer.enumerateTokens(in: text.startIndex..<text.endIndex) { tokenRange, _ in\n 62         tokens.append(String(text[tokenRange]))\n 63         return true\n 64     }\n 65     return tokens\n 66 }\n 67 \n 68 let entityTagger = NLTagger(tagSchemes: [.nameType])\n 69 let entityOptions: NLTagger.Options = [.omitPunctuation, .omitWhitespace, .joinNames]\n 70 let entityTagTypess: [NLTag] = [.personalName, .placeName, .organizationName]\n 71 \n 72 public func getAllEntities(text: String) -> ([String],[String],[String]) {\n 73     var words: [(String, String)] = []\n 74     var people: [String] = []\n 75     var places: [String] = []\n 76     var organizations: [String] = []\n 77     entityTagger.string = text\n 78     entityTagger.enumerateTags(in: text.startIndex..<text.endIndex, unit: .word,\n 79         scheme: .nameType, options: entityOptions) { tag, tokenRange in\n 80         if let tag = tag, entityTagTypess.contains(tag) {\n 81             let word = String(text[tokenRange])\n 82             if tag.rawValue == \"PersonalName\" {\n 83                 people.append(word)\n 84             } else if tag.rawValue == \"PlaceName\" {\n 85                 places.append(word)\n 86             } else if tag.rawValue == \"OrganizationName\" {\n 87                 organizations.append(word)\n 88             } else {\n 89                 print(\"\\nERROR: unkown entity type: |\\(tag.rawValue)|\")\n 90             }\n 91             words.append((word, tag.rawValue))\n 92         }\n 93         return true\n 94     }\n 95     return (people, places, organizations)\n 96 }\n 97 \n 98 func splitLongStrings(_ s: String, limit: Int) -> String {\n 99     var ret: [String] = []\n100     let tokens = s.split(separator: \" \")\n101     var subLine = \"\"\n102     for token in tokens {\n103         if subLine.count > limit {\n104             ret.append(subLine)\n105             subLine = \"\"\n106         } else {\n107             subLine = subLine + \" \" + token\n108         }\n109     }\n110     if subLine.count > 0 {\n111         ret.append(subLine)\n112     }\n113     return ret.joined(separator: \"\\n\")\n114 }\n

\n\n\n\n

\nViews

\n\n

This is not a book about SwiftUI programming, and indeed I expect many of you dear readers know much more about UI development with SwiftUI than I do. I am not going to list the four view files:

\n\n

MainView.swift
QueryView.swift
AboutView.swift
InfoView.swift

\n\n

\nMain KGN

\n\n

The top level app code in the file KGNApp.swift is fairly simple. I hardcoded the window size for macOS and the window sizes for running this example on iPadOS or iOS are commented out:

\n\n

 1 import SwiftUI\n 2 \n 3 @main\n 4 struct KGNApp: App {\n 5     var body: some Scene {\n 6         WindowGroup {\n 7           MainView()\n 8             .frame(width: 1200, height: 770)    // << here !!\n 9             //.frame(width: 660, height: 770)    // << here !!\n10             //..frame(width: 500, height: 800)    // << here !!\n11         }\n12     }\n13 }\n

\n\n\n\n

I was impressed by the SwiftUI framework. Applications are fairly portable across macOS, iOS, and iPadOS. I am not a UI developer by profession (as this application shows) but I enjoyed learning just enough about SwiftUI to write this example application.

\n\n\n

\nPart 5: Apple Intelligence

\n\n

\nDevelopers Can Now Weave Apple Intelligence Directly Into Their Apps

\n\n

Dear reader, Apple has opened up its new “Apple Intelligence” system to third-party developers, providing a suite of tools and APIs to create more personalized and powerful applications. Developers can primarily leverage this technology through the new Foundation Models framework, which offers direct access to Apple’s on-device generative models. This allows for the integration of sophisticated features like text summarization, content creation, and message rewriting directly within an app’s interface, all while processing user data locally on the device to ensure privacy.

\n\n

Furthermore, developers can utilize an expanded App Intents framework to make their application’s content and functionalities accessible to system-wide services like Siri and Shortcuts. This deeper integration allows users to interact with apps using natural language and create complex, multi-app workflows. For instance, a user could ask Siri to “find all photos of my dog from last summer and create a collage in my favorite editing app,” and the system, through App Intents, would understand and execute this command. The Image Playground API also allows for the seamless inclusion of image generation capabilities, enabling users to create unique visuals within the context of the app they are using.

\n\n

\nKey Advantages for Developers:

\n\n

Enhanced User Experience: By integrating features like personalized content suggestions, intelligent summarization, and natural language interaction, developers can create more intuitive and engaging applications that anticipate user needs.
On-Device Processing for Privacy and Performance: A significant advantage is the on-device nature of Apple Intelligence. This approach enhances user privacy and security by keeping personal data on the device. It also improves app performance and responsiveness by reducing reliance on cloud-based processing.
Access to Powerful Generative Models: Developers gain access to Apple’s sophisticated generative models without the need to build and train their own. This allows for the rapid implementation of advanced AI features that were previously complex and resource-intensive to develop.
Deeper System Integration: The enhanced App Intents framework provides a new level of integration with core iOS, iPadOS, and macOS features. This allows apps to become more discoverable and useful within the broader Apple ecosystem, extending their functionality beyond the confines of the app itself.

\n\n\n

\nUsing Apple Intelligence’s Default System Model To Build a Chat Command Line Tool

\n\n

Here we create a simple command line chat tool. The LLM specific code can also be used in iOS, iPadOS, and macOS applications. This chat tool will use the local system LLM for simple queries and will transparently call a more capable model on Apple’s servers in a secure and privacy preserving sandbox.

\n\n

The following Swift package manifest defines an executable command-line program named chattool designed to run on macOS. The tool relies on Apple’s swift-argument-parser package to process command-line arguments.

\n\n

Package.swift:

\n\n

 1 // swift-tools-version: 6.2\n 2 import PackageDescription\n 3 \n 4 let package = Package(\n 5     name: \"ChatTool\",\n 6     platforms: [.macOS(.v26)],   // macOS 15/16 is fine too\n 7     products: [\n 8         .executable(name: \"chattool\", targets: [\"ChatTool\"])\n 9     ],\n10     dependencies: [\n11         // ⬇︎ Apple’s official argument-parsing package\n12         .package(url: \"https://github.com/apple/swift-argument-parser.git\",\n13                  from: \"1.3.0\")\n14     ],\n15     targets: [\n16         .executableTarget(\n17             name: \"ChatTool\",\n18             // expose the ArgumentParser product to the target\n19             dependencies: [\n20                 .product(name: \"ArgumentParser\", package: \"swift-argument-parser\")\n21                 // FoundationModels is an Apple framework, no SPM entry needed\n22             ],\n23             path: \"Sources/ChatTool\"          // adjust if your path differs\n24         )\n25     ]\n26 )\n

\n\n\n\n

ChatTool.swift:

\n\n

This Swift code implements a command-line chat interface that interacts directly with Apple’s native FoundationModels framework. Upon launch, it verifies the system’s default language model is available, initializes a LanguageModelSession with a hard-coded system prompt and temperature, and then enters a read-evaluate-print loop. The program continuously accepts user input from the console and sends it to the language model for processing until the user quits.

\n\n

The core of the implementation leverages modern Swift concurrency (async/await) to handle the model’s output as an asynchronous stream. For each user prompt, it iterates through the text fragments as they are generated by session.streamResponse, writing only the new characters to standard output to create a real-time, typewriter-like effect. To enhance usability, it uses a DispatchSource to set up a signal handler for SIGINT (Ctrl+C), allowing a user to cancel the current in-progress stream from the model without terminating the entire chat application.

\n\n

 1 import Foundation\n 2 import FoundationModels\n 3 import Dispatch\n 4 \n 5 @main\n 6 struct ChatCLI {\n 7     static func main() async throws {\n 8         // Hard-coded defaults\n 9         let temperature  = 0.2\n10         let sysPrompt    = \"You are a helpful assistant.\"\n11 \n12         // Verify model\n13         let model = SystemLanguageModel.default\n14         guard model.isAvailable else {\n15             throw RuntimeError(\"Model unavailable: \\(model.availability)\")\n16         }\n17 \n18         let session = LanguageModelSession(instructions: sysPrompt)\n19         print(\"Temperature: \\(temperature)\")\n20         print(\"System Prompt: \\(sysPrompt)\")\n21         let options = GenerationOptions(temperature: temperature)\n22 \n23         print(\"Apple-Intelligence chat (streaming, T=0.2). Type /quit to exit.\\n\")\n24 \n25         while true {\n26             print(\"Enter your message: \", terminator: \"\")\n27             guard let prompt = readLine(strippingNewline: true) else { break }\n28             if prompt.isEmpty || prompt == \"/quit\" { break }\n29 \n30             var previous = \"\"       // text already printed\n31 \n32             let task = Task {\n33                 for try await part in session.streamResponse(to: prompt, options: op\\\n34 tions) {\n35                     let delta = part.dropFirst(previous.count) // new characters only\n36                     if !delta.isEmpty {\n37                         FileHandle.standardOutput.write(Data(delta.utf8))\n38                         fflush(stdout)\n39                         previous = part\n40                     }\n41                 }\n42                 print() // newline when complete\n43             }\n44 \n45             // ^C cancels the streaming task\n46             signal(SIGINT, SIG_IGN)\n47             let sigSrc = DispatchSource.makeSignalSource(signal: SIGINT, queue: .mai\\\n48 n)\n49             sigSrc.setEventHandler { task.cancel() }\n50             sigSrc.resume()\n51             defer { sigSrc.cancel() }\n52 \n53             _ = try await task.value\n54         }\n55     }\n56 }\n57 \n58 /// Simple error wrapper\n59 struct RuntimeError: Error, CustomStringConvertible {\n60     let description: String\n61     init(_ msg: String) { description = msg }\n62 }\n

\n\n\n\n

Here are the first few lines of output given the prompt Describe the math for calculating the orbit of Jupiter, then write a very short design for a Python script:

\n\n

 1 $ swift run\n 2 [1/1] Planning build\n 3 Building for debugging...\n 4 [1/1] Write swift-version-39B54973F684ADAB.txt\n 5 Build of product 'chattool' complete! (0.16s)\n 6 Temperature: 0.2\n 7 System Prompt: You are a helpful assistant.\n 8 Apple-Intelligence chat (streaming, T=0.2). Type /quit to exit.\n 9 \n10 Enter your message: Describe the math for calculating the orbit of Jupiter, then wri\\\n11 te a very short design for a Python script\n12 Calculating the orbit of Jupiter involves solving Kepler's laws of planetary motion,\\\n13  which describe the elliptical orbits of planets around the Sun. The key equations i\\\n14 nvolve gravitational forces and conservation laws. Here's a brief overview of the ma\\\n15 th involved:\n16 \n17  ### Key Concepts:\n18 \n19 1. **Kepler's Laws:**\n20    - **First Law (Law of Ellipses):** Planets move along ellipses with the Sun at on\\\n21 e focus.\n22    - **Second Law (Law of Equal Areas):** A line segment joining a planet and the Su\\\n23 n sweeps out equal areas during equal intervals of time.\n24    - **Third Law (Law of Harmonies):** The square of the orbital period (\\(T\\)) is p\\\n25 roportional to the cube of the semi-major axis (\\(a\\)): \\(T^2 = \\frac{4\\pi^2}{GM}a^3\\\n26 \\).\n27 \n28 2. **Gravitational Force:**\n29    - The gravitational force between two masses (\\(m_1\\) and \\(m_2\\)) is given by Ne\\\n30 wton's law: \\(F = G \\frac{m_1 m_2}{r^2}\\), where \\(G\\) is the gravitational constant\\\n31  and \\(r\\) is the distance between centers.\n32 \n33 3. **Centripetal Force:**\n34    - For circular orbits, centripetal force equals gravitational force: \\(F = \\frac{\\\n35 mv^2}{r}\\).\n

\n\n\n\n\n

\nUsing Apple Intelligence’s Default System Model To Build a Coding Assistant Command Line Tool

\n\n

This tool looks in the current directory and all subdirectories for source code files and describes them and then enters a chat loop for talking about the code.

\n\n

Package.swift:

\n\n

 1 // swift-tools-version: 6.2\n 2 // The swift-tools-version declares the minimum version of Swift required to build t\\\n 3 his package.\n 4 \n 5 import PackageDescription\n 6 \n 7 let package = Package(\n 8     name: \"CodingCLI\",\n 9 \n10     // 1️ Tell SwiftPM we require at least macOS 12 so\n11     //    `Task.value`, async/await, and FoundationModels are available.\n12     platforms: [\n13         .macOS(.v26)\n14     ],\n15 \n16     products: [\n17         .executable(name: \"CodingCLI\", targets: [\"CodingCLI\"])\n18     ],\n19 \n20     targets: [\n21         .executableTarget(\n22             name: \"CodingCLI\",\n23 \n24             // 2️ Link the system framework that ships with Xcode 17+\n25             //    (no external dependency required).\n26             linkerSettings: [\n27                 .linkedFramework(\"FoundationModels\")\n28             ]\n29         )\n30     ]\n31 )\n

\n\n\n\n

CodingCLI.swift:

\n\n

 1 import Foundation\n 2 import FoundationModels\n 3 import Dispatch\n 4 \n 5 @main\n 6 struct CodingCLI {\n 7     static func main() async throws {\n 8         // ---- 1. Gather candidate source files ----\n 9         let exts = [\"swift\", \"py\", \"lisp\"]\n10         var blobs: [String] = []\n11 \n12         let enumerator = FileManager.default.enumerator(atPath: \".\")!\n13 \n14         while let path = enumerator.nextObject() as? String { // avoids @noasync\n15             guard let ext = path.split(separator: \".\").last,\n16                   exts.contains(ext.lowercased()) else { continue }\n17 \n18             if let data = FileManager.default.contents(atPath: path),\n19                data.count < 8 * 1024 {                           // keep size filter\n20                 let text = String(decoding: data, as: UTF8.self) // non-optional\n21                 blobs.append(\"### \\(path) ###\\n\\(text)\")\n22             }\n23         }\n24 \n25         let doc      = blobs.joined(separator: \"\\n\")\n26         let summary  = try await Self.summarize(doc)\n27         print(\"\\n=== Project Summary ===\\n\\(summary)\\n\")\n28 \n29         // ---- 2. Start interactive chat loop ----\n30         let session  = LanguageModelSession(instructions:\n31                                             \"You are a helpful assistant.\")\n32         let options  = GenerationOptions(temperature: 0.2)\n33         print(\"Apple-Intelligence chat (streaming, T=0.2).  Type /quit to exit.\\n\")\n34 \n35         while let prompt = readLine(strippingNewline: true) {\n36             if prompt.isEmpty || prompt == \"/quit\" { break }\n37 \n38             var printed = \"\"\n39             let task = Task {\n40                 for try await part in session.streamResponse(to: prompt,\n41                                                              options: options) {\n42                     let delta = part.dropFirst(printed.count)\n43                     if !delta.isEmpty {\n44                         FileHandle.standardOutput.write(Data(delta.utf8))\n45                         fflush(stdout)\n46                         printed = part\n47                     }\n48                 }\n49                 print()\n50             }\n51 \n52             signal(SIGINT, SIG_IGN)\n53             let sig = DispatchSource.makeSignalSource(signal: SIGINT, queue: .main)\n54             sig.setEventHandler { task.cancel() }\n55             sig.resume()\n56             defer { sig.cancel() }\n57 \n58             _ = try await task.value\n59         }\n60     }\n61 \n62     // ---- 3. Helper: summarize all code ----\n63     static func summarize(_ text: String) async throws -> String {\n64         let session = LanguageModelSession(\n65             instructions: \"\"\"\n66             Summarize the following multi-file project. \\\n67             For each file give one bullet explaining its role, then \\\n68             a two-sentence overall description.\n69             \"\"\"\n70         )\n71         let prompt = text.prefix(24 * 1024)                 // safety window\n72         let resp   = try await\n73                      session.respond(to: String(prompt),\n74                                      options: GenerationOptions(temperature: 0))\n75         return resp.content                         // unwrap Response<String>\n76     }\n77 }\n

\n\n\n\n

Here is the output for running this tool in its own source directory:

\n\n

 1 $ swift run\n 2 Building for debugging...\n 3 [8/8] Applying CodingCLI\n 4 Build of product 'CodingCLI' complete! (3.23s)\n 5 \n 6  === Project Summary ===\n 7  ### test.py\n 8 - **Role:** This script interacts with Groq to perform a chat completion task.\n 9 - **Description:** It sets up a chat session using Groq's API, sends a specific mess\\\n10 age, and prints the response, showcasing how to utilize Groq for conversational AI t\\\n11 asks.\n12 \n13  ### Package.swift\n14 - **Role:** Defines the Swift package configuration for the CodingCLI project.\n15 - **Description:** This file specifies the project's platform requirements, defines \\\n16 the executable product, and outlines the executable target with necessary dependenci\\\n17 es.\n18 \n19  ### Sources/CodingCLI/CodingCLI.swift\n20 - **Role:** Serves as the entry point for the CodingCLI application, handling file s\\\n21 ummarization and chat interaction.\n22 - **Description:** It processes source files to generate a summary, and manages an i\\\n23 nteractive chat loop using a language model, demonstrating integration of summarizat\\\n24 ion and conversational AI within a Swift package.\n25 \n26 Apple-Intelligence chat (streaming, T=0.2).  Type /quit to exit.\n

\n\n\n\n\n

\nBook Wrap Up

\n\n

I hope that you dear reader enjoyed this short book. While I enjoy programming in Swift and appreciate how well Apple has integrated machine learning capabilities in their iOS/iPadOS/macOS ecosystems, I still find myself writing most of my experimental code in Lisp languages and using Python for deep learning experiments and projects. That said, I am very happy that I have done the work to add Swift, CoreML, and SwiftUI to my personal programming tool belt.

\n\n

I usually update my eBooks so if there is some topic or application domain that you would like added to future versions of this book, then please let me know. My email address is markw <at> markwatson <dot> com.

\n\n

\n\n","tocStructure",[365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438],{"_75":76,"_42":77,"_69":-5,"_78":79,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":85,"_69":-5,"_78":86,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":90,"_69":-5,"_78":91,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":95,"_69":-5,"_78":96,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":98,"_69":-5,"_78":99,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":101,"_69":-5,"_78":102,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":95,"_69":-5,"_78":104,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":106,"_69":-5,"_78":107,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":109,"_69":-5,"_78":110,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":112,"_69":-5,"_78":113,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":115,"_69":-5,"_78":116,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":118,"_69":-5,"_78":119,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":121,"_69":-5,"_78":122,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":124,"_69":-5,"_78":125,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":127,"_69":-5,"_78":128,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":131,"_69":-5,"_78":132,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":135,"_69":-5,"_78":136,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":138,"_69":-5,"_78":139,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":141,"_69":-5,"_78":142,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":144,"_69":-5,"_78":145,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":148,"_69":-5,"_78":149,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":151,"_69":-5,"_78":152,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":154,"_69":-5,"_78":155,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":157,"_69":-5,"_78":158,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":161,"_69":-5,"_78":162,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":164,"_69":-5,"_78":165,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":168,"_69":-5,"_78":169,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":172,"_69":-5,"_78":173,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":175,"_69":-5,"_78":176,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":178,"_69":-5,"_78":179,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":181,"_69":-5,"_78":182,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":184,"_69":-5,"_78":185,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":188,"_69":-5,"_78":189,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":191,"_69":-5,"_78":192,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":195,"_69":-5,"_78":196,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":198,"_69":-5,"_78":199,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":201,"_69":-5,"_78":202,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":205,"_69":-5,"_78":206,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":208,"_69":-5,"_78":209,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":212,"_69":-5,"_78":213,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":215,"_69":-5,"_78":216,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":218,"_69":-5,"_78":219,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":222,"_69":-5,"_78":223,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":225,"_69":-5,"_78":226,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":228,"_69":-5,"_78":229,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":231,"_69":-5,"_78":232,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":234,"_69":-5,"_78":235,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":238,"_69":-5,"_78":239,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":242,"_69":-5,"_78":243,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":245,"_69":-5,"_78":246,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":248,"_69":-5,"_78":249,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":252,"_69":-5,"_78":253,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":255,"_69":-5,"_78":256,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":258,"_69":-5,"_78":259,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":262,"_69":-5,"_78":263,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":265,"_69":-5,"_78":266,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":268,"_69":-5,"_78":269,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":271,"_69":-5,"_78":272,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":274,"_69":-5,"_78":275,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":277,"_69":-5,"_78":278,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":281,"_69":-5,"_78":282,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":285,"_69":-5,"_78":286,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":288,"_69":-5,"_78":289,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":291,"_69":-5,"_78":292,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":294,"_69":-5,"_78":295,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":297,"_69":-5,"_78":298,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":301,"_69":-5,"_78":302,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":304,"_69":-5,"_78":305,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":307,"_69":-5,"_78":308,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":311,"_69":-5,"_78":312,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":89,"_42":314,"_69":-5,"_78":315,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":317,"_69":-5,"_78":318,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":321,"_69":-5,"_78":322,"_71":80,"_92":-5,"_93":-5,"_83":-5},{"_75":76,"_42":325,"_69":-5,"_78":326,"_71":80,"_92":-5,"_93":-5,"_83":-5},"publicChapterContent","nextChapter","sections",[],"routes/_store+/_layout","routes/_store+/_readers+/_layout","actionData","errors"]

\nPart 1: Introduction and Short Examples

Table of Contents

\nCover Material, Copyright, and License

\nPreface

\nNotes on the new June 2025 Book Edition

\nRequests from the Author

\nHire the Author as a Consultant

\nNotes on the Second Edition

\nBook Structure

\nRequests from the Author

\nHire the Author as a Consultant

\nParts of this Book are Specific for macOS and iOS, with Some Support for Linux

\nCode for this Book

\nAuthor’s Background

\nCover Art

\nCoreML Libraries Used in this Book

\nSwift 3rd Party Libraries

\nAcknowledgements

\nPart 1: Introduction and Short Examples

\nSetting Up Swift for Command Line Development

\nInstalling Swift Packages

\nCreating Swift Packages

\nAccessing Libraries that You Write in Other Projects

\nBackground Information for Writing Swift Command Line Utilities

\nUsing Shell Processes

\nFileIO Examples

\nSwift REPL

\nWeb Scraping

\nRunning in the Swift REPL

\nPart 2: Large Language Models

\nUsing the OpenAI LLM APIs

\nCore Architecture

\nKey Features

\nAuthentication and Configuration

\nChat Completions

\nUtility Functions

\nTechnical Implementation Details

\nNetwork Communication

\nError Handling

\nData Parsing

\nRunning Tests

\nUsing APIs for Anthropic Claude LLMs

\nRunning the examples

\nUsing Groq APIs to Open Weight LLM Models

\nImplementation of a Client Library for the Groq APIs

\nExplanation of the Swift Groq API Code

\n1. Setting Up the API

\n2. Structure of a Chat Request

\n3. Making an HTTP POST Request

\n4. Chat Functionality

\n5. Usage Functions

\nRunning the Tests

\nUsing the xAI Grok LLM

\nImplementation of a Grok API Client Library

\nUsing Ollama to Run Local LLMs

\nRunning the Ollama Service

\nOllama Wrap Up

\nUsing Apple’s MLX Framework to Run Local LLMs

\nMLX Framework History

\nMLX Resources on GitHub

\nExample Application for MLX Swift Examples Repository

\nAnalysis of Swift and SwiftUI Code in the LLMEval Application

\nImports

\nThe ContentView Struct

\nUI Layout

\nThe LLMEvaluator Class

\nPart 3: Apple’s CoreML and NLP Libraries

\nDeep Learning Introduction

\nSimple Multi-layer Perceptron Neural Networks

\nDeep Learning

\nNatural Language Processing Using Apple’s Natural Language Framework

\nUsing Apple’s NaturalLanguage Swift Library

\nA simple Wrapper Library for Apple’s NLP Models

\nDocuments Question Answering Using OpenAI GPT4 APIs and a Local Embeddings Vector Database

\nExtending the String Class

\nImplementing a Local Vector Database for Document Embeddings

\nCreate Local Embeddings Vectors From Local Text Files With OpenAI GPT APIs

\nUsing Local Embeddings Vector Database With OpenAI GPT APIs

\nWrap Up for Using Local Embeddings Vector Database to Enhance the Use of GPT3 APIs With Local Documents

\nPart 4: Knowledge Representation and Data Acquisition