Roboweb

Roboweb combines OpenAI's powerful gpt-3.5-turbo API with JupyterLab for AI-assisted development, offering flexible deployment options through Docker and Kubernetes. This technical overview walks you through the platform's architecture, from local development to cloud deployment, while highlighting its secure API management and robust feature set.

Technical Specifications and Platform

Roboweb employs OpenAI's gpt-3.5-turbo API through users' OpenAI API keys, with all API keys securely stored in browser local storage and never transmitted to Roboweb's servers. The platform's technical foundation includes robust deployment capabilities, supporting both Docker and Kubernetes environments.

For local development, users require Docker Desktop and can initiate the JupyterLab environment by running:

docker run -it --rm -p 8888:8888 \

-v "$PWD":/home/jovyan/work hamelsmu/roboweb

This command serves JupyterLab on port 8888, with connection details printed to the terminal. To set up the development environment, users should create a conda virtual environment (specifically python=3.9) and install JupyterLab along with the necessary extensions. The provided installation commands enable the Roboweb extension and server.

The platform's deployment architecture extends to Kubernetes, where it leverages a publicly available Google Cloud Docker image located at us-west1-docker.pkg.dev/roboweb-images/roboweb-images/kubeflow/jupyterlab:latest. This image combines JupyterLab with the Roboweb extension and operates based on Kubeflow's JupyterLab container image. Users without Kubeflow access can deploy using minimal Kubernetes manifests provided in the jlewi/roboweb-docs repository, following these steps:

1. Clone the repository: git clone https://github.com/jlewi/roboweb-docs.git

2. Create a namespace: kubectl create namespace roboweb

3. Apply the manifest: kustomize build k8s/manifests | kubectl apply -f

To access the deployed JupyterLab instance, users need to port-forward to the notebook pod:

kubectl -n roboweb port-forward notebook-0 8888:8888

The platform securely manages user communications and support through email at roboweb-users@googlegroups.com and GitHub issue tracking at jlewi/roboweb-docs for bug reports and feature requests.

Installation and Basic Usage

Running Roboweb locally requires Docker Desktop and can be initiated with these commands:

docker run -it --rm -p 8888:8888 \

-v "$PWD":/home/jovyan/work hamelsmu/roboweb

This command serves JupyterLab on port 8888, with connection details printed to the terminal. For a seamless experience, users should create a conda virtual environment (specifically python=3.9) and set up JupyterLab with the necessary extensions:

conda create -n robo -c conda-forge python=3.9 jupyterlab

conda activate robo

python -m pip install roboweb-extension roboweb-server

python -m jupyter serverextension enable --py roboweb_server

jupyter lab

Once installed, users need to sign in or create an account through the right-hand navigation window. Logging in opens the Roboweb extension in the right half of the screen. After logging in, users can access settings to enter their OpenAI API key, which is stored locally and never transmitted to Roboweb's servers.

The platform provides comprehensive support for users, with documentation available at jlewi/roboweb-docs and issue tracking on GitHub. For deployment assistance, users can refer to detailed guides that walk them through creating a Kubernetes namespace and applying the necessary manifests. The deployment process begins with cloning the repository and creating a dedicated namespace, followed by applying the deployment manifest.

Feature Highlights

The extension integrates seamlessly with JupyterLab, offering developers enhanced productivity features. Upon detecting errors in a cell, Roboweb presents users with the option to fix the issue, streamlining the debugging process. This intelligent error detection mechanism provides users with actionable steps to correct their code, making the development workflow more efficient.

Roboweb's deployment flexibility allows users to run the application locally using Docker or scale to cloud environments through Kubernetes. The platform's architecture ensures that OpenAI API keys remain secure, stored locally in browser storage and never transmitted to Roboweb's servers. This design choice upholds user privacy while enabling robust AI-assisted development capabilities.

Deployment Options

Roboweb's deployment infrastructure supports both Docker-based and Kubernetes environments, with comprehensive documentation available in the jlewi/roboweb-docs repository. The platform utilizes OpenAI's gpt-3.5-turbo API through users' OpenAI API keys, which are stored securely in browser local storage and never transmitted to Roboweb's servers.

For users familiar with Docker, the platform provides a publicly accessible Google Cloud Docker image located at us-west1-docker.pkg.dev/roboweb-images/roboweb-images/kubeflow/jupyterlab:latest. This image combines JupyterLab with the Roboweb extension and operates based on Kubeflow's JupyterLab container image. However, accessing the public Docker registry requires authentication via a Google account.

Alternative deployment options exist for users without Kubeflow infrastructure. The official documentation references minimal Kubernetes manifests available in the jlewi/roboweb-docs/k8s/manifests directory. To deploy Roboweb using these manifests, users should follow these steps:

1. Clone the documentation repository: git clone https://github.com/jlewi/roboweb-docs.git

2. Create a Kubernetes namespace: kubectl create namespace roboweb

3. Apply the deployment manifest: kustomize build k8s/manifests | kubectl apply -f

After deployment, users must port-forward to the notebook pod to access JupyterLab: kubectl -n roboweb port-forward notebook-0 8888:8888. The application can then be accessed through http://localhost:8888 in a web browser.

The platform's architecture ensures secure API key management, storing credentials locally in browser storage rather than transmitting them to Roboweb's servers. This design maintains user privacy while enabling AI-assisted development features within the JupyterLab environment.

Security and Data Handling

Security and data handling in Roboweb are designed with user privacy in mind. All OpenAI API keys are stored locally in browser storage and never transmitted to Roboweb's servers, ensuring that user credentials remain secure throughout the development process. This local storage approach aligns with best practices for handling sensitive information in development environments.

The platform maintains confidentiality by storing chat history on its servers, which helps preserve context across sessions while keeping API keys secure. This hybrid approach balances usability with security, allowing users to maintain control over their API keys while benefiting from persistent session data.

For deployment scenarios, both Docker-based and Kubernetes environments support secure API management. The Docker images used for deployment are publicly accessible through Google Cloud, though authentication is required to browse the registry. These images include JupyterLab with the Roboweb extension pre-installed, based on Kubeflow's container image.

The deployment process ensures that users maintain control over their API keys by storing them locally. For local development, users can run Roboweb using a single Docker command, while Kubernetes deployments follow a well-documented process that keeps API keys secure. The platform provides detailed instructions for both deployment methods, ensuring that users can implement secure practices regardless of their environment.