Yet another Anthropic API client for Swift.
Just add to your Package.swift under dependencies
let package = Package(
name: "MyPackage",
products: [...],
targets: [
.target(
"YouAppModule",
dependencies: [
.product(name: "AnthropicSwiftSDK", package: "AnthropicSwiftSDK")
]
)
],
dependencies: [
.package(url: "https://github.com/fumito-ito/AnthropicSwiftSDK.git", .upToNextMajor(from: "0.11.0"))
]
)let anthropic = Anthropic(apiKey: "YOUR_OWN_API_KEY")
let message = Message(role: .user, content: [.text("This is test text")])
let response = try await anthropic.messages.createMessage([message], maxTokens: 1024)This library currently supports Messages API. If you need legacy Text Completion API, please make PRs or Issues.
Send a structured list of input messages with text, image, pdf and/or tool content, and the model will generate the next message in the conversation.
The Messages API can be used for for either single queries or stateless multi-turn conversations.
let anthropic = Anthropic(apiKey: "YOUR_OWN_API_KEY")
let message = Message(role: .user, content: [.text("This is test text")])
let response = try await anthropic.messages.createMessage([message], maxTokens: 1024)
for content in response.content {
switch content {
case .text(let text, _):
print(text)
case .image(let imageContent, _):
// handle base64 encoded image content
case .document(let documentContent, _):
// handle base64 encoded pdf content
case .toolResult(let toolResult):
// handle tool result
case .toolUse(let toolUse):
// handle tool object
}
}Send a structured list of input messages with text and/or image content, and the model will generate incrementally stream the response using server-sent events (SSE).
let anthropic = Anthropic(apiKey: "YOUR_OWN_API_KEY")
let message = Message(role: .user, content: [.text("This is test text")])
let stream = try await anthropic.messages.streamMessage([message], maxTokens: 1024)
for try await chunk in stream {
switch chunk.type {
case .messageStart:
// handle message start object with casting chunk into `StreamingMessageStartResponse`
}
}The Message Batches API is a powerful, cost-effective way to asynchronously process large volumes of Messages requests. This approach is well-suited to tasks that do not require immediate responses, reducing costs by 50% while increasing throughput.
This is especially useful for bulk operations that don’t require immediate results.
Here's an example of how to process many messages with the Message Batches API:
let anthropic = Anthropic(apiKey: "YOUR_OWN_API_KEY")
let messages = [
Message(role: .user, content: [.text("Write a haiku about robots.")]),
Message(role: .user, content: [.text("Write a haiku about robots. Skip the preamble; go straight into the poem.")]),
Message(role: .user, content: [.text("Who is the best basketball player of all time?")]),
Message(role: .user, content: [.text("Who is the best basketball player of all time? Yes, there are differing opinions, but if you absolutely had to pick one player, who would it be?")])
// ....
]
let batch = MessageBatch(
customId: "my-first-batch-request",
parameter: .init(
messages: messages,
maxTokens: 1024
)
)
let response = try await anthropic.messageBatches.createBatches(batches: [batch])This library also supports an Admin API for managing workspaces and organization members.
- Get Organization Member: Retrieve details about a specific organization member.
- List Organization Members: List organization members.
- Remove Organization Member: Remove a member from the organization.
- Update Organization Member: Update the role or details of an existing organization member.
Example of updating an organization member:
let admin = AnthropicAdmin(adminAPIKey: "YOUR_OWN_ADMIN_API_KEY")
try await admin.organizationMembers.get(userId: "user_01WCz1FkmYMm4gnmykNKUu3Q")- Get Organization Invites: Retrieve details about a specific organization invitation.
- List Organization Invites: List organization invitations.
- Remove Organization Invites: Remove a invitation from the organization.
- Create Organization Invites: Create a new organization invitation.
Example of updating an organization invitation:
let admin = AnthropicAdmin(adminAPIKey: "YOUR_OWN_ADMIN_API_KEY")
try await admin.organizationInvites.list()- Get Workspace: Retrieve details about a specific workspace.
- List Workspaces: List workspaces.
- Create Workspace: Create a new workspace.
- Archive Workspace: Archive an existing workspace.
- Update Workspace: Update the details of an existing workspace.
Example of creating a workspace:
let admin = AnthropicAdmin(adminAPIKey: "YOUR_OWN_ADMIN_API_KEY")
try await admin.workspaces.get(workspaceId: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")- Get Workspace Member: Retrieve details about a specific workspace member.
- List Workspace Members: List workspace members.
- Create Workspace Member: Add a new member for the workspace.
- Remove Workspace Member: Remove a member from the workspace.
- Update Workspace Member: Update the role or details of an existing workspace member.
Example of updating an workspace member:
let admin = AnthropicAdmin(adminAPIKey: "YOUR_OWN_ADMIN_API_KEY")
try await admin.workspaceMembers.get(userId: "user_01WCz1FkmYMm4gnmykNKUu3Q")- Get Organization Member: Retrieve details about a specific API key.
- List Organization Members: List API keys.
- Update Organization Member: Update the status or name of an existing API key.
Example of updating an organization member:
let admin = AnthropicAdmin(adminAPIKey: "YOUR_OWN_ADMIN_API_KEY")
try await admin.apiKeys.get(apiKeyId: "apikey_01Rj2N8SVvo6BePZj99NhmiT")Token counting enables you to determine the number of tokens in a message before sending it to Claude, helping you make informed decisions about your prompts and usage. With token counting, you can
- Proactively manage rate limits and costs
- Make smart model routing decisions
- Optimize prompts to be a specific length
let anthropic = Anthropic(apiKey: "YOUR_OWN_API_KEY")
let message = Message(role: .user, content: [.text("Find flights from San Francisco to a place with warmer weather.")])
let response = try await anthropic.countTokens.countTokens(
[message],
maxTokens: 1024,
tools: [
.computer(.init(name: "my_computer", displayWidthPx: 1024, displayHeightPx: 768, displayNumber: 1),
.bash(.init(name: "bash"))
]
)The token counting endpoint accepts the same structured list of inputs for creating a message, including support for system prompts, tools, images, and PDFs. The response contains the total number of input tokens.
Claude is capable of interacting with external client-side tools and functions, allowing you to equip Claude with your own custom tools to perform a wider variety of tasks.
AnthropicSwiftSDK supports Tool Use in conjunction with the @FunctionCalling macro and FunctionCalling-AnthropicSwiftSDK extension. You can easily handle Tool Use with the following code.
@FunctionCalling(service: .claude)
struct MyFunctionTools: ToolContainer {
@CallableFunction
/// Get the current stock price for a given ticker symbol
///
/// - Parameter: The stock ticker symbol, e.g. AAPL for Apple Inc.
func getStockPrice(ticker: String) async throws -> String {
// code to return stock price of passed ticker
}
}
let result = try await Anthropic(apiKey: "your_claude_api_key")
.createMessage(
[message],
maxTokens: 1024,
tools: MyFunctionTools().anthropicSwiftTools // <= pass tool container here
)Prompt caching is a powerful feature that optimizes your API usage by allowing resuming from specific prefixes in your prompts.
You can cache large text content, e.g. “Pride and Prejudice”, using the cache_control parameter. This enables reuse of this large text across multiple API calls without reprocessing it each time. Changing only the user message allows you to ask various questions about the book while utilizing the cached content, leading to faster responses and improved efficiency.
Here’s an example of how to implement prompt caching with the Messages API using a cache_control block:
let anthropic = Anthropic(apiKey: "YOUR_OWN_API_KEY")
let message = Message(role: .user, content: [.text("Analyze the major themes in Pride and Prejudice.")])
let response = try await anthropic.messages.createMessage(
[message],
system: [
.text("You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n", nil),
.text("<the entire contents of Pride and Prejudice>", .ephemeral)
],
maxTokens: 1024
)The upgraded Claude 3.5 Sonnet model is capable of interacting with tools that can manipulate a computer desktop environment.
By implementing the following code, you can instruct Claude to return commands for executing tasks on a computer
let anthropic = Anthropic(apiKey: "YOUR_OWN_API_KEY")
let message = Message(role: .user, content: [.text("Find flights from San Francisco to a place with warmer weather.")])
let response = try await anthropic.messages.createMessage(
[message],
maxTokens: 1024,
tools: [
.computer(.init(name: "my_computer", displayWidthPx: 1024, displayHeightPx: 768, displayNumber: 1),
.bash(.init(name: "bash"))
]
)By introducing an extension Swift package, it is possible to access the Anthropic Claude API through AWS Bedrock and Vertex AI. The supported services are as follows:
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
Please make sure to update tests as appropriate.