OpenIM Server

The OpenIMSDK is designed for integration into client applications and provides the following core capabilities:

Main Features

• Local Storage: Manages data on the client device.
• Listener Callbacks: Notifies the application of IM events.
• API Wrapping: Simplifies interaction with the server.
• Connection Management: Handles the lifecycle of the connection to OpenIMServer.

Main Modules

1. Initialization and Login
2. User Management
3. Friends Management
4. Group Functions
5. Session Handling

For the Go implementation, refer to the OpenIM SDK Core repository.

The v3.8.3-patch.16 release introduced several significant features, including:

• Webhooks: Support for online status webhooks and msgDBSave webhooks (triggered when data is saved to the DB).
• Messaging Enhancements: Support for stream messages, Markdown text message types, and specifying ContentType in SendMsg.
• Infrastructure & Scaling: Support for AWS, Redis Sentinel, MongoDB Replicaset mode, and running in single process mode.
• Configuration: Introduction of a Config Center, support for server-issued configurations for individual users, and case-insensitive push configuration.
• System Services: Support for an app update service and improved Prometheus monitoring (auto-setting ports).
• API & Logic: Support for GetLastMessage, DeleteConversations interface, and returning modified fields when sending messages.

OpenIM supports several deployment strategies depending on your environment requirements:

1. Source Code Deployment

• Regular Source Code Deployment: Uses the nohup method. Best for development and testing environments.
• Production-Level Deployment: Uses the system method. Provides higher stability and reliability for production environments.

2. Cluster Deployment

• Kubernetes Deployment: Supports deployment via Helm or sealos. Ideal for environments requiring high availability and scalability.

3. Docker Deployment

• Regular Docker Deployment: Best for quick deployments and small-scale projects.
• Docker Compose Deployment: Recommended for complex multi-container applications as it provides more convenient service management and configuration.

OpenIM is an open-source instant messaging (IM) solution designed specifically for developers to integrate into their own applications, rather than being a standalone chat app like Telegram or Signal. It consists of two main components:

1. OpenIMSDK: A client-side SDK designed to be integrated into client applications. It handles local storage, listener callbacks, API encapsulation, and connection management.
2. OpenIMServer: A backend service providing the core IM capabilities. It is built on a microservices architecture and supports cluster modes including gateways and multiple RPC services.

OpenIM provides the necessary tools and frameworks for implementing features like message sending/receiving, user management, and group management within your own software ecosystem.

OpenIMSDK is a specialized IM SDK designed for embedding into client applications to work with OpenIMServer. It is built using Golang and supports cross-platform deployment to ensure a consistent access experience across all platforms.

Key Features:

• Local storage
• Listener callbacks
• API wrapping
• Connection management

Main Modules:

1. Initialization and Login
2. User Management
3. Friend Management
4. Group Functions
5. Conversation Management

The OpenIMSDK is designed for integration into client applications and provides a consistent experience across platforms. It is built with Golang and supports cross-platform deployment.

Key functional modules include:

• Initialization and Login: Setting up the SDK and authenticating users.
• User Management: Handling user profiles and identities.
• Friend Management: Managing social connections and friend lists.
• Group Functions: Handling group creation, membership, and interactions.
• Session Processing: Managing chat sessions and message flows.

Core features provided by the SDK include local storage, listener callbacks, API encapsulation, and connection management.

The OpenIMServer is the backend engine providing high-performance messaging capabilities.

Key Characteristics:

• Microservices Architecture: Supports cluster mode, including gateways and multiple RPC services.
• Scalability: Designed to support massive user bases, including super-large groups with hundreds of thousands of users, tens of millions of users, and billions of messages.
• Deployment Options: Can be deployed via source code, Kubernetes, or Docker.

Business Extension Features:

• REST API: Allows business systems to perform backend tasks like creating groups or sending push notifications.
• Webhooks: Enables the server to send requests to your business server before or after specific events (e.g., before or after a message is sent).

The OpenIMServer is a high-performance backend designed to support massive scale (millions of users, tens of thousands of group members, and billions of messages).

Key architectural features:

• Microservices Architecture: Supports cluster modes with gateways and multiple RPC services.
• Deployment Options: Can be deployed via source code, Kubernetes, or Docker.
• REST API: Provides backend interfaces for business systems to perform tasks like group creation and message pushing.
• Webhooks: Allows extending business logic by sending requests to your business server based on event triggers (before/after specific events).

OpenIMServer is built for high scalability and flexible deployment. Key characteristics include:

• Microservices Architecture: Supports cluster mode with a gateway and multiple RPC services.
• Scalability: Designed to support massive user bases, including groups with millions of users and billions of messages.
• Deployment Options: Can be deployed via source code, Kubernetes, or Docker.
• Extensibility:
  • REST API: Allows external business systems to trigger IM actions like group creation or message pushing.
  • Webhooks: Enables business logic expansion by sending callbacks to your business servers before or after specific IM events.

OpenIMSDK is a client-side package designed specifically for integration with OpenIMServer. It is built using Golang and supports cross-platform deployment to ensure consistent access across different platforms.

Key Features

• Local Storage: Manages data on the client side.
• Listener Callbacks: Handles event notifications.
• API Wrapper: Provides a simplified interface for server calls.
• Connection Management: Handles the lifecycle of the connection to the server.

Core Modules

1. Initialization and Login
2. User Management
3. Friend Management
4. Group Functions
5. Conversation Management

For the Go implementation, see the GO SDK repository.