The Chat API built for serious scale

import React from "react";
import * as Ably from "ably";
import {
  ChatClient,
  ChatClientProvider,
  ChatRoomProvider,
  RoomOptionsDefaults,
} from "@ably/chat";

// Initialize Ably Realtime client
const ablyClient = new Ably.Realtime({
  clientId: "ably-chat",
  key: "<API_KEY>",
});

// Create Ably Chat client
const chatClient = new ChatClient(ablyClient, {});

// App component using Ably Chat providers
function App() {
  return (
    <ChatClientProvider client={chatClient}>
      <ChatRoomProvider id="my-chat-room" options={RoomOptionsDefaults}>
        <YourChatComponent />
      </ChatRoomProvider>
    </ChatClientProvider>
  );
}

export default App;

import Ably
import AblyChat
import Foundation

// Create the Ably clients
let realtimeOptions = ARTClientOptions()
realtimeOptions.key = "<API_KEY>"
realtimeOptions.clientId = "ably-chat"
let realtime = ARTRealtime(options: realtimeOptions)
let chatClient = DefaultChatClient(realtime: realtime, clientOptions: nil)

// Get a chat room
let room = try await chatClient.rooms.get(
    roomID: "my-chat-room", options: RoomOptions.allFeaturesEnabled)

// Start receiving messages from the server
try await room.attach()

// Add a listener for new messages in the chat room
let messagesSubscription = try await room.messages.subscribe()
Task {
    // Subscribe to messages
    for await message in messagesSubscription {
        print("Message received: \(message.text)")
    }
}

// Send our message
_ = try await room.messages.send(
    params: .init(text: "Hello, World!"))

import kotlinx.coroutines.delay
import io.ably.lib.realtime.AblyRealtime
import io.ably.lib.types.ClientOptions
import com.ably.chat.ChatClient
import com.ably.chat.RoomOptions

// Create the Ably clients
val realtimeClient = AblyRealtime(
    ClientOptions().apply {
        key = "<API_KEY>"
        clientId = "ably-chat"
    }
)
val chatClient = ChatClient(realtimeClient)

// Get our chat room and subscribe to messages
val room = chatClient.rooms.get("readme-getting-started", RoomOptions.default)
val messageSubscription = room.messages.subscribe { event ->
    println("message received: ${event.message.text}")
}

// Start receiving messages from the server
room.attach()

// Send a message
room.messages.send(text = "Hello, World!")