# Installation

You can install RBC using `conda` (recommended) or `mamba`, which is a faster implementation of `conda`. For more information, see [the Mamba documentation](https://mamba.readthedocs.io/en/latest/index.html).

```bash
conda install -c conda-forge rbc

# or to install rbc to a new environemnt, run
conda create -n rbc -c conda-forge rbc
conda activate rbc

# check if rbc installed succesfully
python -c 'import rbc; print(rbc.__version__)'
```

You can also use `pip` for package management:

```bash
pip install rbc-project
# check if rbc installed succesfully
python -c 'import rbc; print(rbc.__version__)'
```

## Quick Start

{% hint style="danger" %}
The following assumes that you have an instance of HEAVY.AI running. UDFs and UDTFs are enabled with the flags `--enable-runtime-udfs and --enable-table-functions`. For more information on installing HEAVY.AI, see [Installation](/v8.3.0/installation-and-configuration/installation.md).

To summarize:

```bash
conda create -n heavy-ai-env heavydb -c conda-forge
conda activate heavy-ai-env
mkdir -p data
initheavy data -f
heavydb --enable-runtime-udfs --enable-table-functions
```

{% endhint %}

To inspect the test database—provided by default—connect another terminal to the database using

```bash
heavysql --passwd HyperInteractive
```

The following example shows a simple UDF that converts a numerical temperature from Fahrenheit to Celsius. The code defines the function, registers it, and runs it on the server.

```python
from rbc.heavydb import RemoteHeavyDB

heavy = RemoteHeavyDB(
    user='admin',
    password='HyperInteractive',
    host='localhost',
    port=6274,
    dbname='heavyai',
)

@heavy('double(double)')
def fahrenheit2celsius(f):
    return (f - 32) * 5 / 9

print(fahrenheit2celsius(32))
# 'fahrenheit2celsius(CAST(32 AS DOUBLE))'

# other functions?
...

# after defining all functions, they should be registered
# to the database
heavy.register()
```

The instance of class `RemoteHeavyDB` connects to the HeavyDB instance, and the object it returns can be used to register functions. Then, you define a normal Python function `fahrenheit2celsius`. The function is decorated using the instance `heavy` of the class `RemoteHeavyDB`, and it is provided with the function signature `'double(double)'`. With this modification, the decorated function expects a single argument that is a double-precision floating-point value and also returns a double-precision floating-point value. The syntax is similar to function annotations in C/C++.

After you defined all functions you want to be available on the HeavyDB server, you should register them all at once with `heavy.register()`.

`fahrenheit2celsius` can now be used in SQL on the HeavyDB server. You can use tools like [heavyai](https://heavyai.readthedocs.io) or [ibis](https://ibis-project.org) (via the [ibis-heavyai](https://github.com/heavyai/ibis-heavyai) backend) to help construct queries from Python. The following example shows a function call from SQL.

```sql
SELECT fahrenheit2celsius(col) FROM my_table
```

The function is then applied element-wise on the column `col` of the table `my_table`.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.heavy.ai/v8.3.0/python-data-science/python-user-defined-functions-udfs-with-the-remote-backend-compiler-rbc/installation.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.