Within the earlier tutorials, we explored how Basis Fashions work in iOS 26 and how one can begin constructing AI-powered options utilizing this new framework. We additionally launched the @Generable macro, which makes it straightforward to transform generated responses into structured Swift varieties.
Now, in Half 3 of the Basis Fashions sequence, we’ll dive into one other highly effective functionality: Software Calling — a characteristic that lets the mannequin work together along with your app’s features to carry out duties, retrieve information, or set off actions based mostly on person enter.
The on-device language mannequin isn’t able to answering each sort of query, particularly people who require real-time information, like the present climate or the newest inventory costs. In different circumstances, you may want the mannequin to entry your app’s personal information to reply precisely. That’s the place Software Calling is available in that it permits the mannequin to delegate particular duties to your app’s features or exterior APIs.
On this tutorial, we’ll prolong the Ask Me Something app. Whereas the on-device mannequin can deal with normal queries, it doesn’t have entry to up-to-date details about trending motion pictures. To bridge that hole, we’ll use Software Calling to combine with the The Film Database (TMDB) API, enabling the mannequin to reply to movie-related questions utilizing reside information.
Utilizing TMDB APIs
In case you ask the Ask Me Something app about trending motion pictures, the on-device language mannequin received’t have the reply—it merely doesn’t have entry to that form of real-time data and should recommend checking different sources as a substitute. Let’s repair that utilizing Software Calling and the TMDB API. With this setup, each time a person asks a movie-related query, the mannequin received’t reply with “I don’t know.” As an alternative, it is going to robotically name the exterior API and return the related data instantly within the app.
Within the Xcode venture, create a MovieService file and insert the next code:
// Mannequin for a Film
struct Film: Codable, Identifiable {
let id: Int
let title: String
let overview: String
// Coding keys to match API response
enum CodingKeys: String, CodingKey {
case id
case title
case overview
}
}
// Mannequin for the API response
struct TrendingMoviesResponse: Codable {
let outcomes: [Movie]
}
// Service class to fetch trending motion pictures
class MovieService {
// Base URL for TMDB API
personal let baseURL = "https://api.themoviedb.org/3"
personal let apiKey = ""
// Operate to fetch trending motion pictures utilizing async/await
func fetchTrendingMovies() async throws -> [Movie] {
// Assemble the URL for trending motion pictures
let urlString = "(baseURL)/trending/film/day?api_key=(apiKey)"
guard let url = URL(string: urlString) else {
throw URLError(.badURL)
}
// Carry out the community request
let (information, response) = strive await URLSession.shared.information(from: url)
// Verify for legitimate HTTP response
guard let httpResponse = response as? HTTPURLResponse,
(200...299).comprises(httpResponse.statusCode) else {
throw URLError(.badServerResponse)
}
// Decode the JSON response
let decoder = JSONDecoder()
let trendingResponse = strive decoder.decode(TrendingMoviesResponse.self, from: information)
return trendingResponse.outcomes
}
}
Ensure you exchange the worth of apiKey with your personal TMDB API key. In case you haven’t signed up but, head over to themoviedb.org and register for a free account to get your API key.
The code above is pretty simple: it calls the net API to fetch trending motion pictures, then parses the response and decodes it into an array of Film objects.
Subsequent, we’ll use Software Calling to set off the code in MovieService each time the person asks about trending motion pictures. To get began, create a brand new file named GetTrendingMoviesTool.swift and add the next code:
import FoundationModels
struct GetTrendingMoviesTool: Software {
let title = "getTrendingMovies"
let description = "Get trending motion pictures and their data"
let service = MovieService()
@Generable
struct Arguments {
}
func name(arguments: Arguments) async throws -> [String] {
let motion pictures = strive await service.fetchTrendingMovies()
let formattedMovies = motion pictures.map { film in
"(film.title): (film.overview)"
}
return formattedMovies
}
}
We outline a GetTrendingMovieTool struct that conforms to the Software protocol — that is the usual option to implement Software Calling within the Basis Fashions framework. The protocol requires you to specify a title and description for the instrument, together with an Arguments struct to symbolize any parameters the instrument would possibly want. On this case, we don’t require extra enter, so we outline an empty Arguments construction.
In case you needed to filter trending motion pictures by style, you could possibly outline Arguments like this:
@Generable
struct Arguments {
@Information(description: "The style to fetch trending motion pictures")
var style: String
}
When the instrument is triggered by the mannequin, the name methodology is robotically executed. Inside it, we name the fetchTrendingMovies() methodology from our service. After receiving the outcomes, we format them to show every film’s title and overview.
With the trending film instrument in place, integrating it into your app is easy. Merely open ContentView and replace the LanguageModelSession initialization as follows:
@State personal var session = LanguageModelSession(instruments: [GetTrendingMoviesTool()])
You may present customized instruments by passing them by way of the instruments parameter when initializing the language mannequin session. That’s it! The language mannequin will robotically invoke GetTrendingMoviesTool each time it detects a query associated to trending motion pictures.
Construct and run the app, then strive asking the identical query once more. This time, the mannequin will efficiently reply with trending film data by invoking the instrument.
Abstract
On this tutorial, we explored instrument calling, a strong addition to the Basis Fashions framework in iOS 26. In contrast to fundamental textual content technology, instrument calling permits the on-device language mannequin to work together along with your app’s features or entry exterior companies.
With instrument calling, you possibly can considerably prolong the mannequin’s capabilities. Whether or not it’s operating customized logic or fetching real-time information by way of APIs, the mannequin can now carry out context-aware duties past its built-in information.
I hope you’ve loved this tutorial sequence and really feel impressed to begin constructing smarter, AI-powered options utilizing the Basis Fashions framework.