Skip to main content
A complete guide to installing and configuring RLM for your projects.

​
Installation

​
Prerequisites

  • Python 3.11 or higher
  • An API key from a supported LLM provider (OpenAI, Anthropic, etc.)
# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create and activate virtual environment
uv init && uv venv --python 3.12
source .venv/bin/activate

# Install RLM in editable mode
uv pip install -e .

​
Optional: Modal Support

For cloud-based sandboxed execution: 
# Install Modal extra
uv pip install -e ".[modal]"

# Authenticate Modal
modal setup

​
Optional: Docker Support

For containerized execution, ensure Docker is installed and running: 
# Verify Docker is available
docker --version

​
Your First RLM Call

​
Step 1: Set Up API Keys

Create a .env file in your project root: 
# .env
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
PORTKEY_API_KEY=...

​
Step 2: Basic Usage

import os
from dotenv import load_dotenv
from rlm import RLM

load_dotenv()

rlm = RLM(
    backend="openai",
    backend_kwargs={
        "api_key": os.getenv("OPENAI_API_KEY"),
        "model_name": "gpt-4o",
    },
)

result = rlm.completion("Calculate the 50th Fibonacci number using Python.")
print(result.response)

​
Step 3: Enable Verbose Output

rlm = RLM(
    backend="openai",
    backend_kwargs={
        "api_key": os.getenv("OPENAI_API_KEY"),
        "model_name": "gpt-4o",
    },
    verbose=True,
)
This will display:
  • Each iteration’s LM response
  • Code blocks being executed
  • Stdout/stderr from execution
  • Final answer when reached

​
Understanding the RLM Class

​
Constructor Arguments

ArgumentTypeDefaultDescription
backendstr"openai"LM provider backend
backend_kwargsdictNoneBackend-specific configuration
environmentstr"local"Execution environment type
environment_kwargsdictNoneEnvironment configuration
max_depthint1Maximum recursion depth
max_iterationsint30Max REPL iterations per call
custom_system_promptstrNoneOverride default system prompt
other_backendslistNoneAdditional backends for sub-calls
other_backend_kwargslistNoneConfigs for additional backends
loggerRLMLoggerNoneLogger for trajectory tracking
verboseboolFalseEnable console output

​
The completion() Method

result = rlm.completion(
    prompt="Your input text or context",
    root_prompt="Optional: A short prompt visible to the root LM"
)
Parameters:
  • prompt: The main context/input (string or dict). This becomes the context variable in the REPL.
  • root_prompt: Optional hint shown to the root LM (useful for Q&A tasks).
Returns: RLMChatCompletion with:
  • response: The final answer string
  • usage_summary: Token usage statistics
  • execution_time: Total time in seconds
  • root_model: Model name used
  • prompt: Original input

​
Choosing an Environment

RLM supports three execution environments:

​
Local (Default)

Code runs in the same Python process with sandboxed builtins. 
rlm = RLM(
    backend="openai",
    backend_kwargs={"model_name": "gpt-4o"},
    environment="local",
)
Pros: Fast, no setup required
Cons: Less isolation from host process

​
Docker

Code runs in a Docker container with full isolation. 
rlm = RLM(
    backend="openai",
    backend_kwargs={"model_name": "gpt-4o"},
    environment="docker",
    environment_kwargs={
        "image": "python:3.11-slim",
    },
)
Pros: Containerized isolation, reproducible
Cons: Requires Docker, slower startup Code runs in Modal’s cloud sandboxes for full isolation. 
rlm = RLM(
    backend="openai",
    backend_kwargs={"model_name": "gpt-4o"},
    environment="modal",
    environment_kwargs={
        "app_name": "my-rlm-app",
        "timeout": 600,
    },
)
Pros: Cloud-native, scalable, fully isolated
Cons: Requires Modal account, network latency

​
Choosing a Backend

​
OpenAI

rlm = RLM(
    backend="openai",
    backend_kwargs={
        "api_key": os.getenv("OPENAI_API_KEY"),
        "model_name": "gpt-4o",
        # Optional: custom base URL
        # "base_url": "https://api.openai.com/v1",
    },
)

​
Anthropic

rlm = RLM(
    backend="anthropic",
    backend_kwargs={
        "api_key": os.getenv("ANTHROPIC_API_KEY"),
        "model_name": "claude-sonnet-4-20250514",
    },
)

​
Portkey (Router)

rlm = RLM(
    backend="portkey",
    backend_kwargs={
        "api_key": os.getenv("PORTKEY_API_KEY"),
        "model_name": "@openai/gpt-5-nano",
    },
)

​
OpenRouter

rlm = RLM(
    backend="openrouter",
    backend_kwargs={
        "api_key": os.getenv("OPENROUTER_API_KEY"),
        "model_name": "openai/gpt-4o",
    },
)

​
vLLM (Local)

rlm = RLM(
    backend="vllm",
    backend_kwargs={
        "base_url": "http://localhost:8000/v1",
        "model_name": "meta-llama/Llama-3-70b",
    },
)

​
Logging and Debugging

​
Enable Logging

from rlm import RLM
from rlm.logger import RLMLogger

logger = RLMLogger(log_dir="./logs")

rlm = RLM(
    backend="openai",
    backend_kwargs={"model_name": "gpt-4o"},
    logger=logger,
    verbose=True,
)

result = rlm.completion("...")

​
Log File Format

Logs are JSON-lines files with: 
{"type": "metadata", "root_model": "gpt-4o", "max_iterations": 30, ...}
{"type": "iteration", "iteration": 1, "response": "...", "code_blocks": [...]}
{"type": "iteration", "iteration": 2, "response": "...", "final_answer": "..."}

​
Visualizer

Use the included visualizer to explore trajectories: 
cd visualizer/
npm install
npm run dev
Upload .jsonl log files to visualize:
  • Iteration timeline
  • Code execution results
  • Sub-LM call traces
  • Token usage

​
Next Steps