> For the complete documentation index, see [llms.txt](https://docs.rhinofcp.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rhinofcp.com/frequently-asked-questions/frequently-asked-questions-faqs.md).
# Frequently Asked Questions (FAQs)
Answers to questions often asked about Rhino FCP
## Setup and Configuration
Which hardware configurations are compatible with the Rhino FCP Platform?
The RH client has been successfully installed on a wide range of hardware configurations, including dedicated servers (Rhino Boxes), VMs provisioned on existing servers on-prem, and cloud-based instances on various clouds (AWS, GCP, Azure).
We have minimal requirements for hardware specifications, but they heavily depend on the kind of computation task the user is looking to perform (i.e. GPU is not required for a Rhino Client installation).
How can I setup or change my ECR credentials?
Before starting, please ensure you have completed all the steps within [FCP Client Installation and Environment Configuration](/getting-started/quick-start-guide/fcp-client-installation-and-environment-configuration.md). This will ensure that your dependencies have been installed. It will also show you how to retrieve your ECR credentials. To setup or re-configure your ECR your will need your **AWS Access Key ID** and your **AWS Secret Access Key**.
#### Configuring your AWS CLI with your ECR Credentials
{% stepper %}
{% step %}
#### Open a terminal or command prompt.
Type in the command:
```bash
aws configure
```
{% endstep %}
{% step %}
#### Enter your credentials.
The code block below shows what you will need to enter at each step of the prompt.
```bash
> aws configure
AWS Access Key ID [None]: YOUR_AWS_ACCESS_KEY_ID
AWS Secret Access Key [None]: YOUR_AWS_SECRET_ACCESS_KEY
Default region name [None]: us-east-1
Default output format [None]: json
```
As a reminder of what each value should be:
* **AWS Access Key ID** - The AWS Access Key ID from your FCP profile
* **AWS Secret Access Key** - The AWS Secret Access Key from your FCP profile
* **Default region name** - us-east-1
* **Default output format** - json
{% endstep %}
{% endstepper %}
How do I log in to Rhino FCP?
Sign in using the email address associated with your account and your password. If your organization uses **Google** or **Microsoft Azure Single Sign-On (SSO)**, select the appropriate sign-in option instead of entering a password.
**Learn more:** → [Log in to Rhino FCP](/getting-started/quick-start-guide/log-in-to-rhino-fcp.md)
How do I reset my Rhino FCP password?
On the sign-in page, click **Can't login?**, enter the email address associated with your account, and select **Reset Password**. You'll receive an email with instructions to create a new password.
**Learn more:** → [Resetting Your Rhino FCP Password](/getting-started/quick-start-guide/resetting-your-rhino-fcp-password.md)
## Importing and Exporting Data
How can I import data in my local environment onto my Rhino FCP client using SFTP?
The process of moving data from your local environment to your Rhino FCP client using SFTP depends on the operating system of your local machine.
#### Connecting to your Rhino FCP Client via SFTP from MacOS, Linux & Windows 10+
{% stepper %}
{% step %}
Open a terminal or command prompt on your respective operating system, and navigate to the folder where the data that you would like to upload are located.
{% endstep %}
{% step %}
Connect to your Rhino FCP Client via SFTP
* Retrieve your SFTP server IP and credentials from your Rhino FCP profile page. If you need a quick refresher on how to do that, see [Viewing and Adjusting Your Settings](/settings/viewing-and-adjusting-your-settings.md).
* Connect to your Rhino FCP client via SFTP, by entering the following.
Note: Ensure to replace `RHINO_CLIENT_IP_ADDRESS` in the below command with the credentials found in your profile.
```bash
> sftp rhinosftp@RHINO_CLIENT_IP_ADDRESS
```
{% endstep %}
{% step %}
Next, you will be prompted to enter your SFTP password, and if everything is entered properly you will be connected to your Rhino FCP client and your command line should change to look like the following:
```bash
sftp>
```
**For additional help with common commands within the SFTP terminal interface, check out the section** [**Common Commands when SFTP'ing Data**](#01H7BJ37P6X1GA3C4DXHDHEFB0) **.**
{% endstep %}
{% endstepper %}
#### Connecting to your Rhino FCP Client via SFTP from Other Operating Systems
{% stepper %}
{% step %}
To SFTP data from other Operating Systems to your Rhino FCP client, you will need to first install an SFTP client, like [Cyberduck](https://cyberduck.io/), [WinSCP](https://winscp.net/eng/index.php), etc.
{% endstep %}
{% step %}
Once your SFTP client has been installed, you can configure a new SFTP connection.
* Retrieve your SFTP server IP and credentials from your Rhino FCP profile page. If you need a quick refresher on how to do that, see [Viewing and Adjusting Your Settings](/settings/viewing-and-adjusting-your-settings.md).
* If you are successfully connected to your SFTP client, you should see two separate panels, one displaying your local machines file system and a second showing your Rhino FCP client's filesystem.
{% endstep %}
{% step %}
Using the STFP client to upload your data:
* On the local machine file system panel, navigate to the folder where your data is located.
* On the Rhino FCP client file system panel, navigate to where you would like to place the data.
Note: It is recommended that you create folders for your datasets to keep things organized.
* Drag the files from the local machine file system panel to the Rhino FCP client file system panel to upload your data to the Rhino FCP client server.
{% endstep %}
{% endstepper %}
#### Common Commands when SFTP'ing Data
Use the following commands to create folders, navigate to different folders, view folder contents, and upload data.
**Create a new folder called DIRECTORY\_NAME within your Rhino FCP client**
```bash
sftp> mkdir DIRECTORY_NAME
```
**Change to the specified directory, DIRECTORY\_NAME within your Rhino FCP client**
```bash
sftp> cd DIRECTORY_NAME
```
**List all files within the current directory on your Rhino FCP client**
```bash
sftp> ls
```
**Upload the specified file FILE\_NAME on your local machine to the current directory of your Rhino FCP client**
```bash
sftp> put FILE_NAME
```
**Upload the folder and all of its contents on your local machine to the current directory of your Rhino FCP client**
```bash
sftp> put -r DIRECTORY_NAME
```
**Exit out of the SFTP connection**
```bash
sftp> exit
```
## Writing and Running Code
How can I pass and use parameters in my code?
If you want to re-use your code, but need to make some small changes without hardcoding them, **Run Parameters** and **Run Secrets** can be very helpful.
#### Passing Run Parameters
When you are ready to run your code, you'll be able to provide parameters in either **RUN PARAMETERS** or **RUN SECRETS**, see a screenshot below and more detail in [What is a Code Object?](/creating-and-running-code-objects/what-is-a-code-object.md).
#### Loading/Using Run Parameters
To use the parameters, simply access them by reading the JSON file in which they are stored. The parameters will be stored in "/input/run\_params.json" and in "/input/secret\_run\_params.json" for **RUN PARAMETERS** and **RUN SECRETS PARAMETERS** respectively. For example, let's say you want to pass "my\_parameter" = 55555, in RUN PARAMETERS. In the UI, you'll set the following RUN PARAMETER:
```json
{"my_parameter": 55555}
```
If you were to write Python code, in your code first you'd read /input/run\_params.json:
```python
parameter_key = "my_parameter"
run_params = {}
run_params_filename = "/input/run_params.json"
try:
with open(run_params_filename, "r") as run_params_file:
run_params = json.load(run_params_file)
except IOError:
logging.error("No params file found")
sys.exit(1)
except json.JSONDecodeError:
logging.error("Invalid JSON found in params file")
sys.exit(1)
if parameter_key not in run_params:
logging.error(f"Key '{parameter_key}' not found in run parameters")
sys.exit(1)
```
and last you'd access the value of your parameter as follows:
```python
my_parameter_value = run_params[parameter_key]
```
For RUN SECRETS PARAMETERS the process would be almost identical except that you would set the parameters in the RUN SECRET PARAMETERS input form, and you would read them from /input/secret\_run\_params.json.
How do I find a UID for an object (data schema, dataset, code object, or code run)?
To find and copy an object's UID, open the page for that object. If the object has versions, go to the version you want. Then open the three-dot menu for that row, as shown below:
The menu is on the right side of the row. Select it, then choose **Copy UID**.
Projects and collaborators do not have versions. Open the object, then use the same three-dot menu to copy its UID.
When should I use a Python Code Snippet vs. a Python Code Standalone File?
* **Code Snippet** - Ideal for relatively straightforward scripts that primarily utilize basic Python packages, along with Pandas and Numpy. FCP automatically provides access to your cohort data as a Pandas Dataframe named **df.** Additionally, it generates the output cohort of your model from this same Dataframe. This setup facilitates elementary Pandas-based operations on your raw input data, such as feature extraction and value normalization.
As an example, consider this Python code snippet:
```python
normalized_df = (df-df.mean())/df.std()
df = normalized_df
```
Executing this code snippet yields an output cohort with z-normalized numerical features, all without requiring any additional code.
* **Standalone File** - This option grants you the freedom to execute varied Python code with custom dependencies, extending beyond Pandas and Numpy. The Standalone File option lets you specify your code's prerequisites, which will be automatically installed within the image generated by FCP. If your code necessitates a specific environment – for instance, to support GPU operations - you can define the Container Base Image that supports it. Use this option for more complex code, which can still be run as a single file. Unlike the ***Code Snippet***, no additional "hidden" functionality is included here.
* **Upload File(s)** - This option is similar to "Standalone File", but allows you to provide your code in more than one file, e.g., multiple Python files and/or shell scripts. Files can include non-Python files of any format, such as configuration files, model parameter files, and so forth. You just have to upload the files you need, or a folder(s), and select the entry point in the text box that appears when this option is selected. The entry point is the file that you'd like your container to run. Be sure to specify code requirements and the container environment as needed.
How can I use external files at run time?
Your workgroup has a unique cloud storage (an S3 bucket on Rhino Orchestrator) to upload non-sensitive data that might be needed during code run, e.g., open-source large LLM model weights.
{% hint style="warning" %}
Cloud storage (specified in *Workgroup code and model artifacts storage* section in the instructions that follow) is owned by Rhino. **Please DO NOT upload sensitive information such as proprietary datasets.** For sensitive data, please use the instructions in [Importing, Viewing a Dataset's Configuration, and Exporting Datasets](/datasets/registering-configuring-and-exporting-datasets.md) instead.
{% endhint %}
#### Overview
For your code to be able to access files while running in your agent we need do 4 steps:
#### Find the bucket to upload your files
The bucket is created as part of the onboarding process into the FCP by client request, you can find it in your settings page under Containers & Artifacts. Here is how to find it.
{% stepper %}
{% step %}
In your project, select the settings button (it looks like a sprocket at the bottom left side of the page.
{% endstep %}
{% step %}
In the Settings menu, which is near the top of the screen on the left side of the window, select Containers & Artifacts.
{% endstep %}
{% step %}
Your storage bucket and bucket prefix appear in the *Workgroup code and model artifacts storage* part of the page.
{% endstep %}
{% endstepper %}
#### Upload files to your designated bucket
AWS offers many alternative ways to upload files to an S3 bucket. We've also provided a script in our user\_resource repository you can use: [upload-file-to-s3.sh](https://github.com/RhinoHealth/user-resources/blob/f2d3107eb85ab2abb4fb68ef25bd3f92538d0ed1/utils/upload-file-to-s3.sh).
You need to define your S3 credentials and then you can call the script like this:
```bash
./upload-file-to-s3.sh the_folder_to_upload storage_bucket bucket_prefix your_path_in_bucket
```
For the example above, if you wanted to upload files in a local folder (called "local\_folder" in the below example) and store them in a folder in FCP called "my\_files", the command would be:
```bash
./upload-file-to-s3.sh ./local_folder external-files-rhino-health-dev my_files
```
#### Reference your files in your code
When creating your code object, you can reference your external files by referencing them in the following path:
```
/external_data/the_folder_in_s3_you_want_to_upload_to/filename
```
For the example above, assuming you uploaded `model_params.txt` file under `my_files`, the file would be accessible during runtime in
```
/external_data/my_files/model_params.txt
```
An example of Python code to read your file data into a `text` variable would look like as follows:
```python
from pathlib import Path
text = Path('/external_data/my_files/model_params.txt').read_text()
```
#### Use your files in a specific run
Once your code points to your external files, and the code object is created, you can run the code and specify the files you want to use in your code run. In the UI, you can simply select them from a dropdown
Alternatively, you can also use the SDK. See this [notebook to use external files via SDK](https://github.com/RhinoHealth/user-resources/blob/main/examples/rhino-sdk/runtime_external_files.ipynb) for more details.
## Other Questions
How do I know my system is secure?
The Rhino FCP is compliant with SOC2, ISO 27001, GDPR, and HIPAA.
For more info, see our docs on [security](https://app.gitbook.com/o/SKrkLtXReIPmOZjXnWZA/sites/site_qTLxU/s/ydySyCBmy6F7NnGn4bPa/~/edit/~/changes/369/security-and-data-protections) and/or visit our trust center at [trust.rhinofcp.com ](https://trust.rhinofcp.com/)
Which cloud environments are supported?
We currently offer support for Amazon (AWS), Google (GCP), Azure, and Oracle (OCI).
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## 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, and the optional `goal` query parameter:
```
GET https://docs.rhinofcp.com/frequently-asked-questions/frequently-asked-questions-faqs.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
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.