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 sorts.
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 together with your app’s features to carry out duties, retrieve knowledge, or set off actions primarily based on person enter.
The on-device language mannequin isn’t able to answering each kind of query, particularly those who require real-time knowledge, like the present climate or the most recent inventory costs. In different instances, you may want the mannequin to entry your app’s personal knowledge 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 common queries, it doesn’t have entry to up-to-date details about trending films. To bridge that hole, we’ll use Software Calling to combine with the The Film Database (TMDB) API, enabling the mannequin to answer movie-related questions utilizing dwell knowledge.
Utilizing TMDB APIs
Should you ask the Ask Me Something app about trending films, the on-device language mannequin received’t have the reply—it merely doesn’t have entry to that sort of real-time data and will counsel 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 can routinely 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 films
class MovieService {
// Base URL for TMDB API
non-public let baseURL = "https://api.themoviedb.org/3"
non-public let apiKey = ""
// Perform to fetch trending films utilizing async/await
func fetchTrendingMovies() async throws -> [Movie] {
// Assemble the URL for trending films
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 (knowledge, response) = strive await URLSession.shared.knowledge(from: url)
// Examine 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: knowledge)
return trendingResponse.outcomes
}
}
Be sure you change the worth of apiKey with your individual TMDB API key. Should 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 easy: it calls the net API to fetch trending films, 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 films. 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 films and their data"
let service = MovieService()
@Generable
struct Arguments {
}
func name(arguments: Arguments) async throws -> [String] {
let films = strive await service.fetchTrendingMovies()
let formattedMovies = films.map { film in
"(film.title): (film.overview)"
}
return formattedMovies
}
}
We outline a GetTrendingMovieTool struct that conforms to the Software protocol — that is the usual solution 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 characterize any parameters the instrument would possibly want. On this case, we don’t require further enter, so we outline an empty Arguments construction.
Should you wished to filter trending films by style, you possibly can outline Arguments like this:
@Generable
struct Arguments {
@Information(description: "The style to fetch trending films")
var style: String
}
When the instrument is triggered by the mannequin, the name methodology is routinely 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 non-public var session = LanguageModelSession(instruments: [GetTrendingMoviesTool()])
You’ll be able to present customized instruments by passing them by means of the instruments parameter when initializing the language mannequin session. That’s it! The language mannequin will routinely invoke GetTrendingMoviesTool each time it detects a query associated to trending films.
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 primary textual content technology, instrument calling permits the on-device language mannequin to work together together with your app’s features or entry exterior companies.
With instrument calling, you may considerably prolong the mannequin’s capabilities. Whether or not it’s operating customized logic or fetching real-time knowledge by means of APIs, the mannequin can now carry out context-aware duties past its built-in data.
I hope you’ve loved this tutorial sequence and really feel impressed to start out constructing smarter, AI-powered options utilizing the Basis Fashions framework.
