You must have heard about the word “Redux” while working with frontend developers or somewhere else, No ? Let me explain.

>Redux is a pattern and library for managing and updating application state, using events called "actions". It serves as a centralized store for state that needs to be used across your entire application, with rules ensuring that the state can only be updated in a predictable fashion.

This article delves into the integration of the Redux approach in [Android development](https://www.geeksforgeeks.org/introduction-to-android-development/), particularly leveraging the power of MutableLiveData. 

## Understanding Redux in Android

Redux is a state management pattern and library that originated in the JavaScript and [web development](https://blog.hubspot.com/website/website-development) ecosystem but has found its way into various other platforms, including Android.

Redux provides a predictable and centralized way to manage the state of an application, making it easier to develop and maintain complex user interfaces.

In the context of Android, Redux is not a specific library or framework but rather a set of principles and patterns that can be implemented using existing tools and libraries. 

## Redux Principles

It was designed and developed for JavaScript but we can follow the Redux pattern in Android as well, Redux can be described in three fundamental principles.

- CheckSingle source of truth ( Store )
- CheckState is read-only ( State )
- CheckChanges are made with pure functions ( Reducers )

## Android Implementation

According to the Redux principles we will create **three components** but with slight variation. For state update callback we will use **MutableLiveData** an AndroidX lifecycle component which allows us to **observe** the change in the data.

## What are LiveData and Observers?

**Observers** are the functions which observe the changes in the LiveData and get automatically called when it receives any updates.

**LiveData** is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers that are in an active lifecycle state.

*We are using Kotlin to show code examples.*

**State**

A state contains data that is accessible throughout the App. Here we are creating a To Do App for our sample project, so we will be storing the list of tasks in the App State. 

To make our todo list observable we will wrap it with LiveData, similarly you can wrap any type of class with LiveData and make it observable. Moreover you can add as many as variables using LiveData.


```
data class AppState(
    val tasks: LiveData<ArrayList<ToDoTask>>,
    var isLoading: LiveData<Boolean>
)
```

**Reducer**


Reducer contains the logical part, in this class we will create functions to apply CRUD operations. Here we are using a different approach with respect to the Redux principles, we are creating separate functions for different actions instead of action-dispatch functions. 

You can not modify LiveData directly, so first we will cast it to MutableLiveData and then apply changes. For more details about MutableLiveData read official documentation [here](https://developer.android.com/reference/androidx/lifecycle/MutableLiveData#postValue(T)).


```
class Reducer(private val state: AppState) {

    fun addTask(task: ToDoTask) {
        val taskList = state.tasks.value!!
        taskList.add(task)

        // If you are working on Main thread you can use #setValue(),
        // for background thread use #postValue()
        (state.tasks as MutableLiveData).postValue(taskList)
    }

    fun deleteTask(task: ToDoTask): Unit {
        val taskList = state.tasks.value!!
        taskList.remove(task)
        (state.tasks as MutableLiveData).postValue(taskList)
    }

    fun updateTask(index: Int, isChecked: Boolean): Unit {
        val taskList = state.tasks.value!!
        taskList[index].isCompleted = isChecked
        (state.tasks as MutableLiveData).postValue(taskList)
    }

}
```
**Store**

Store is a global object which contains the AppState and the Reducer. We will create our Store class with AppState and Reducer, Initialise AppState with initial state and pass the initial state to the reducer.


```
class Store {
    var state: AppState
    var reducer: Reducer

    init {
        // Initial state
        state = AppState(
            MutableLiveData(ArrayList()),
            MutableLiveData(false)
        )
        reducer = Reducer(state)
    }
}
```

Ok! But, How to Combine these Things Together?

The Store should be accessible throughout the application, so we will need to create a global instance of store. Consequently we will extend the Application class and create a companion object, which will allow us to access the store object App wide.


```
class ThisApp : Application() {

    companion object {
        val store = Store()
    }

}
```

Don’t forget to add ThisApp to AndroidManifest.xml

## CRUD Operations

To modify the App State we need to call reducer functions which we created earlier. Below is the code which shows how to call reducer functions.


```
...
// Add
ThisApp.store.reducer.addTask(ToDoTask(1,"New Task","Description",false))

// Update
itemView.taskCheck.setOnClickListener {
    ThisApp.store.reducer.updateTask(position,!task.isCompleted)
}

// Delete
itemView.deleteTaskBtn.setOnClickListener {
    ThisApp.store.reducer.deleteTask(task)
}

...
```

## Updating the UI

For our To Do App, we require to list the tasks in the recycler view, so we will create an Adapter for it. We will use our tasks array list as a data source for TaskAdapter.


```
class TaskAdapter : RecyclerView.Adapter<TaskViewHolder>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): TaskViewHolder {
        return TaskViewHolder(View.inflate(parent.context, R.layout.task_item_layout, null))
    }

    override fun onBindViewHolder(holder: TaskViewHolder, position: Int) {
        val task = ThisApp.store.state.tasks.value!![position]
        holder.bind(task,position)
    }

    override fun getItemCount(): Int {
        return ThisApp.store.state.tasks.value!!.size
    }
}
...
```

But there is a problem, the TaskAdapter doesn’t know that the data has been changed, so we need to notify it about that. For this purpose we will add an observer for the tasks list in our activity as shown below


```
...
override fun onCreate(savedInstanceState: Bundle?) {
    // Add observer to specific live data
    ThisApp.store.state.tasks.observe(this) {
        taskAdapter.notifyDataSetChanged()
        if (it.size == 0) emptyView.visibility = View.VISIBLE
        else emptyView.visibility = View.GONE
    }
}
...

override fun onDestroy() {
    super.onDestroy()
    // Remove all observers
    ThisApp.store.state.tasks.removeObservers(this)
}

......
override fun onCreate(savedInstanceState: Bundle?) {
    // Add observer to specific live data
    ThisApp.store.state.tasks.observe(this) {
        taskAdapter.notifyDataSetChanged()
        if (it.size == 0) emptyView.visibility = View.VISIBLE
        else emptyView.visibility = View.GONE
    }
}
...

override fun onDestroy() {
    super.onDestroy()
    // Remove all observers
    ThisApp.store.state.tasks.removeObservers(this)
}

...
```

Whenever the list gets updated, it will call **taskAdapter.notifyDataSetChanged()** which will update the recycler view.
Yesss ! we made it. That's how we can apply the Redux approach in Android using LiveData.

You can clone the sample project from [github](https://github.com/Edugem-Technologies/ToDoApp-ARL).

## Conclusion

Integrating the Redux approach with MutableLiveData in Android provides a robust and scalable architecture for state management. 

The unidirectional data flow, immutability, and predictability offered by Redux contribute to a more maintainable and debuggable codebase. 

By leveraging MutableLiveData for reactive updates, developers can seamlessly connect the Redux architecture with the Android UI, creating a powerful combination for building modern and responsive applications. 

As Android development continues to evolve, embracing such architectural patterns becomes increasingly essential for crafting high-quality, scalable, and maintainable apps.


**Note:**
This approach might not suit all types of projects, in the end it depends on you to choose appropriate architecture as per your project requirements. The LiveData which we used is a part of MVVM architecture recommended by the Android officials.

References: 

[1. AndroidX](https://developer.android.com/jetpack/androidx/migrate)

[2. Redux](https://redux.js.org/understanding/thinking-in-redux/three-principles)

[3. Live Data](https://developer.android.com/topic/libraries/architecture/livedata)

[4. Mutable Live Data](https://developer.android.com/reference/androidx/lifecycle/MutableLiveData)

Tags: Android,Kotlin,Redux,Javascript,Design Pattern,Technology

large_redux-approach-in-android-using-mutablelivedata.9b0c5488.jpg

medium_redux-approach-in-android-using-mutablelivedata.9b0c5488.jpg

small_redux-approach-in-android-using-mutablelivedata.9b0c5488.jpg

thumbnail_redux-approach-in-android-using-mutablelivedata.9b0c5488.jpg

Redux

Discover efficient state management in Android using LiveData and implement Redux principles with reducers, store, and observers for scalable apps.

Redux Approach in Android, Using MutableLiveData

Redux Approach in Android Using MutableLiveData

Have you ever been on a quest to make your code the best it can be, only to find out later that you accidentally let some sneaky bugs slip in? 

It's like trying to build the perfect sandcastle, only to have it crumble because you missed a step! 

But fear not, intrepid coder! There's a magical tool called Git pre-commit hooks that can help you keep your code kingdom safe and tidy.

Imagine Git pre-commit hooks as your loyal guardians, standing at the gates of your code kingdom, checking every change you make before it's allowed to enter. 

They're like friendly dragons that sniff out any potential problems and warn you before it's too late! 

## Advantages 

### 1. Error Prevention

[Pre-commit](https://pre-commit.com/) hooks catch potential errors before they're committed, helping you avoid headaches down the line.

### 2. Consistency

By enforcing coding standards and best practices, pre-commit hooks ensure that your codebase remains consistent and easy to maintain.

### 3. Time Saving

Automating checks with pre-commit hooks saves you time that would otherwise be spent manually reviewing code.

### 4. Quality Assurance 

Pre-commit hooks provide instant feedback, empowering you to make improvements and ensure the highest quality for your code.

## Disadvantages 

### 1. Setup Complexity

Configuring and maintaining pre-commit hooks may require some initial setup and ongoing maintenance, especially for larger projects.

### 2. False Positives

Overly strict hooks may occasionally flag legitimate changes as errors, leading to frustration for developers.

### 3. Local Dependencies

Pre-commit hooks only run on developers' local machines, so issues may still slip through if hooks aren't set up uniformly across the team.

### 4. Potential Overhead 

Depending on the complexity of the checks performed, pre-commit hooks may introduce overhead and slow down the commit process.

For example, let's say you're working on a new feature to make your website more visually appealing. 

With Git pre-commit hooks, you can ensure that every piece of code you write meets the highest quality standards before it's added to your main codebase. 

This prevents accidentally adding code that could cause problems or degrade the website's functionality instead of enhancing it.

## Prerequisites

We will explore setup procedures using Python.

### 1. Install Git

If you haven't already, install Git on your system. You can download and install Git from the official website: [Git Downloads](https://git-scm.com/downloads).

### 2. Create a Python Virtual Environment

Navigate to your Python project directory and create a virtual environment using venv or virtualenv:

```
python3  -m  venv  venv
```

Activate the virtual environment:

```
source  venv/bin/activate
```
## Setting Up Pre-Commit Hooks

### 1. Install Required Packages

Install the necessary Python packages, including pre-commit, which provides the framework for managing pre-commit hooks:


```
pip install pre-commit
```
### 2. Define Pre-Commit Configuration

Create a ".pre-commit-config.yaml" file in the root of your project directory and define the pre-commit hooks you want to use. Here's an example configuration:

```
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
  rev: v3.4.0
  hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
```
- **a. repos:** This is the top-level key that lists all repositories from which pre-commit hooks are fetched.

- **b. repo:** This specifies the URL of the repository that contains the pre-commit hooks you want to use. In this case, it points to the pre-commit-hooks repository on GitHub.

- **c. rev:** This indicates the specific version (or revision) of the repository to use. Here, v3.4.0 is the tag or version of the pre-commit-hooks repository that will be used.

- **d. hooks:** This is a list of individual hooks from the specified repository that will be run. Each hook has an id that uniquely identifies it.

   - **i. trailing-whitespace:** This hook removes any trailing whitespace from the ends of lines in your files. Trailing whitespace can cause unnecessary changes and issues in version control, so it's good practice to remove it.

  - **ii. end-of-file-fixer:** This hook ensures that a file ends with exactly one new line. Many text editors and version control systems expect this convention, and it helps avoid unnecessary diffs and potential issues with certain tools.

  - **iii. check-yaml:** This hook checks YAML files for syntax errors. YAML is a common configuration file format, and syntax errors can lead to hard-to-debug issues. This hook helps ensure your YAML files are properly formatted.

### 3. Install Pre-Commit Hooks

Run the following command to install the pre-commit hooks defined in your configuration file:

```
pre-commit install  
```
### 4. Run Pre-Commit Hooks

To run pre-commit hooks on all files in your project, use:

```
pre-commit run --all-files
```
To run pre-commit hooks on a single file, specify the path to the file:

```
pre-commit run --files path/to/file.py
```
To skip a particular hook during the pre-commit check, use the --skip option followed by the hook ID:

```
pre-commit run --all-files --skip trailing-whitespace
```
To run a specific hook, use the --hook option followed by the hook ID:

```
pre-commit run --all-files --hook check-yaml
```
### 5. Commit Changes

Make some changes to your Python files and commit them using Git. The pre-commit hooks will automatically run before the commit is finalized.

### 6. Create Custom Pre-Commit Hooks

To create a custom pre-commit hook, create a Python script in your project directory. For example, create a file named "my_custom_hooks.py" with the following contents:

```
# my_custom_hooks.py

def my_custom_hook():
	# Your custom hook logic goes here
	pass
```
### 7. Register Custom Pre-Commit Hooks

In your ".pre-commit-config.yaml" file, add an entry for your custom hook, specifying the path to the script and any additional configuration options:

```
- repo: local
  hooks:
    - id: my-custom-hook
      name: My Custom Pre-Commit Hook
      entry: python -m my_custom_hooks.my_custom_hook
      language: python
      types: [ python ]
```
- **a. id:** This is a unique identifier for your custom hook. In this case, it is my-custom-hook. 

- **b. name:** This is a human-readable name for the hook. It is My Custom Pre-Commit Hook. This name is used for display purposes, such as in pre-commit output logs.

- **c. entry:** This specifies the command that runs the hook. Here, it uses the python -m command to run a Python module named my_custom_hooks.my_custom_hook. This command should execute your custom hook logic.

- **d. language:** This indicates the programming language in which the hook is written. Here, it is set to Python, indicating that the hook is a Python script.

- **e. types:** This is a list specifying the types of files the hook should run on. In this case, it is set to [Python], meaning the hook will run only on Python files.

This code block configures a custom pre-commit hook that is defined locally within your project. 

The custom hook is a Python script identified by my-custom-hook and named My Custom Pre-Commit Hook. 

When pre-commit runs, it will execute the specified Python module my_custom_hooks.my_custom_hook on Python files in your repository. 

This allows you to implement and enforce custom checks or formatting rules specific to your project's needs, enhancing your code quality and consistency.

By following these setup procedures and using the provided commands, developers can effectively configure and manage Git pre-commit hooks for Python projects, while also having flexibility in running hooks on specific files and controlling hook execution.

Although setting up these tools requires some initial effort, the long-term benefits are significant. 

Reduced bugs, improved code readability, and streamlined development workflows make the investment well worth it. 

Embrace these practices to elevate your coding standards and enjoy a smoother, more efficient development experience.


large_Pre-Commit

medium_Pre-Commit

small_Pre-Commit

thumbnail_Pre-Commit

Pre-Commit

Learn to use Git pre-commit hooks to prevent errors, ensure code consistency, and save time with our step-by-step guide for Python projects.


Keep Your Code Clean With Git Pre-Commit Hooks

Image Source: [AWS](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html)

## Introduction

In today's fast-paced world, machine learning models need to be deployed quickly, efficiently, and at scale. Serverless architectures offer a compelling solution, enabling you to deploy models without managing servers or infrastructure.

This blog post will guide you through leveraging AWS ECR and SageMaker to achieve serverless deployment for your machine learning models.

## Prerequisites and Key Concepts

### 1. Serverless Computing

A paradigm where you pay only for the resources your code consumes, eliminating server management and scaling concerns.

### 2. [AWS ECR (Elastic Container Registry)](https://aws.amazon.com/ecr/)

A managed container registry for storing and managing Docker images used in your AWS deployments.

### 3. [Amazon SageMaker](https://aws.amazon.com/sagemaker/)

A fully managed service for building, training, and deploying machine learning models.

## Procedure

### Step 1: Code Containerization using Docker

**1. Prepare Inference Code**

- Ensure that your inference code generates the final results intended by your model during training.

- Consider adopting a standardised format such as JSON for clarity and compatibility across different systems.

- If required, manage preprocessing and postprocessing tasks within the inference code to ensure accurate and seamless operation.

**2. Build Flask APIs**

**/ping Endpoint:**

- Objective: Verify API health and readiness.
- Return a simple message (e.g., "API is alive!").
- Use a lightweight HTTP status code (e.g., 200 OK) for easy checking.

**/invocations Endpoint:**

- Objective: Receive input data for the model and provide predictions in return.
- Accept input data in a structured format, such as JSON.
- Invoke the prepared inference code using the received data.
- Deliver the final predictions in a consistent format, like JSON.
- Take into account error handling and logging mechanisms to ensure robustness.

**3. Combine Code and APIs**

While consolidating these components for simplicity is understandable, enhancing maintainability and scalability can be achieved by segregating Flask API logic from the inference code. 

Consider separating them into distinct modules for improved organisation. Aim to keep both the Flask app and inference code as streamlined as possible.

### Step 2: Configure AWS CLI

The AWS Command Line Interface (CLI) is a powerful tool for managing AWS resources from the terminal. Follow these steps to set it up:

**Note:** Run the below commands in **bash terminal**.

**1. Check if AWS CLI is installed:**

```
aws cli
```
If the command doesn't respond, CLI is not configured.

**2. Install AWS CLI:**

Please follow this [link](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) to install aws cli based on your OS.

**3. Set up a local user:**

- Create a new user in the Identity and Access Management (IAM) section of the AWS console.
- Give the user full access to ECS with the policy named "AmazonECS_FullAccess."
- Note down the access key and secret access key.

**4. Configure AWS CLI:**

```
aws configure
```
Enter the access key, secret access key, and preferred region. Skip the default output format for now.

**5. Verify the configuration:**

```
aws configure list
```
### Step 3: Push docker image to ECR

After successfully creating a local [Docker](https://www.techtarget.com/searchitoperations/definition/Docker) image and container, the next step is to publish it from our local Docker repository to AWS Elastic Container Registry (ECR), facilitated through Amazon Elastic Container Service (ECS).

Wondering what ECS is? Let me explain.

ECS, or Amazon Elastic Container Service, is a comprehensive container orchestration service. It's fully managed and simplifies the deployment, management, and scalability of containerized applications.

Additionally, Elastic Container Registry (ECR) serves as the dedicated registry for Docker containers stored within ECS. 

In our workflow, we leverage ECS to seamlessly push our Docker container to ECR, ensuring efficient management and deployment of our containerized applications on the AWS platform.

**1. Create a repository in ECR:**

```
aws ecr create-repository --repository-name <repo_name> --region <region_name>
```
Verify repository creation in the AWS console.

![aws](https://bs-cms-media-prod.s3.ap-south-1.amazonaws.com/aws_ce00724239.PNG)

**2. Push Docker image to ECR:**

- Authenticate Docker credentials with AWS:

```
aws ecr get-login-password --region <region_name> | docker login -u AWS --password-stdin <repo_uri>
```

Replace `<region_name>` and `<repo_uri>` accordingly.

- Tag a local Docker image:

```
docker tag <source_image_tag> <target_ecr_repo_uri>
```

- Push the Docker image to ECR:

```
docker push <ecr_repo_uri>
```

![aws 2.PNG](https://bs-cms-media-prod.s3.ap-south-1.amazonaws.com/aws_2_06ce6453c8.PNG)

### Step 4: Model creation in AWS SageMaker

Navigate to the sagemaker -> Inference -> Models

Creating sagemaker model will package your model artifacts docker image for deployment on sagemaker. Below is the snapshot to create a model.

![aws ](https://bs-cms-media-prod.s3.ap-south-1.amazonaws.com/aws_a5e93f8f57.PNG)

### Step 5: Endpoint configuration

Navigate to the sagemaker -> Inference -> Endpoint configuration

Create an endpoint configuration by specifying the necessary parameters related to server configuration. Here, it is crucial to indicate the desired server type – whether 'serverless' or 'provisioned'. 

Additionally, you need to define the 'Memory size' and 'Max Concurrency', representing the maximum concurrent invocations for a single endpoint.

![aws ](https://bs-cms-media-prod.s3.ap-south-1.amazonaws.com/aws_b791dc27c1.PNG)

### Step 6: Endpoint

Navigate to SageMaker -> Inference -> Endpoint

Endpoint configurations in SageMaker allow you to create an endpoint. SageMaker generates an HTTPS URL, enabling you to invoke your endpoint seamlessly through client applications. 

This is achieved using the existing runtime client and making an 'invoke_endpoint' request.

![aws](https://bs-cms-media-prod.s3.ap-south-1.amazonaws.com/aws_8dc23c90b6.PNG)

![aws](https://bs-cms-media-prod.s3.ap-south-1.amazonaws.com/aws_67ed3348b0.PNG)

### Step 7: Testing API

Once the endpoint is successfully deployed, it will automatically display the status 'inService' as it should.

![sagemaker](https://bs-cms-media-prod.s3.ap-south-1.amazonaws.com/sagemaker_20dc9b5d27.PNG)

All details regarding the API URL are provided in the endpoint details. You can directly test your URL through Postman requests or integrate it with your existing services.

## Things to remember

Here are some important points to remember to ensure smooth serverless deployment without encountering issues:

- Always ensure that port 8080 is open within the Docker container. Serverless deployed APIs internally utilise port 8080 for running our Docker code.
- Prepare two APIs: '/ping' and '/invocations'. SageMaker defaults to checking the '/ping' API for health status and the '/invocations' API for inference.
- When containerizing the code, set entry points to run the API code. This ensures that the API automatically starts as soon as the container initiates.
- If the payload can be either JSON, raw text or a file, accommodate this flexibility. For file payloads, instead of sending form data, provide a URL for the file. Using the 'requests' library, the file can be downloaded during the API call rather than sending it directly.
- Remember that during the serverless server build for inference, file storage for payloads is restricted to the '/tmp' directory. No other path is allowed for storing files.

## Conclusion

In conclusion, the decision between serverless and provisioned services when deploying [machine learning](https://www.bombaysoftwares.com/blog/top-machine-learning-applications-in-2024) models with AWS SageMaker and ECR hinges on various factors, each with its own set of advantages and considerations.

### Serverless Deployment

Serverless deployment using AWS SageMaker is an excellent choice for scenarios where flexibility, scalability, and cost efficiency are top priorities. This approach allows for automatic scaling, enabling you to handle varying workloads without manual intervention. 

Serverless architectures are particularly beneficial for applications with sporadic or unpredictable usage patterns, as you only pay for the resources consumed during execution.

When rapid development, ease of management, and the ability to offload infrastructure concerns are paramount, serverless is often the preferred option. 

It's well-suited for scenarios where the development team wants to focus primarily on the machine learning model's logic and less on infrastructure provisioning and management.

### Provisioned Deployment

On the other hand, provisioned services are better suited for situations where predictability, fine-tuned control over resources, and specific performance requirements are crucial. 

Provisioned services provide the necessary stability and control when dealing with steady, predictable workloads or when low-latency performance is a priority.

If your application demands dedicated resources, and you have specific infrastructure requirements that are known and consistent, provisioned services may be the more appropriate choice. 

This approach allows for the customization of instances and infrastructure settings to meet the exact needs of your machine learning workload.

In summary, the decision to go serverless or provisioned depends on the specific requirements and priorities of your machine learning deployment. 

Serverless is advantageous for its flexibility and cost-effectiveness, while provisioned services offer fine-grained control and stability for workloads with well-defined characteristics. 

Careful consideration of these factors will guide you toward the deployment strategy that aligns best with your project's goals.


















large_AWS

medium_AWS

small_AWS

thumbnail_AWS

Explore serverless deployment with AWS ECR and SageMaker. Learn to optimize your workflow efficiently.


Serverless Deployment: Leveraging AWS ECR and SageMaker


Stay informed with insights and updates on the latest technology trends, including cloud computing, AI, machine learning, etc. (17)

Blog

Keep Your Code Clean With Git Pre-Commit Hooks

17th Jul, 2024 | Parth P.

Serverless Deployment: Leveraging AWS ECR and SageMaker

26th Feb, 2024 | Shakirali V.

Redux Approach in Android Using MutableLiveData

Ready to Get Started?

Blog

Keep Your Code Clean With Git Pre-Commit Hooks

17th Jul, 2024 | Parth P.

Serverless Deployment: Leveraging AWS ECR and SageMaker

26th Feb, 2024 | Shakirali V.

Redux Approach in Android Using MutableLiveData

Ready to Get Started?

Open Source Contribution

Build Your Own Chatbot