Enhance RLM Playground with FastAPI integration and new dependencies

- Added FastAPI server for RLM playground, enabling web-based completions.
- Introduced Pydantic models for API requests and responses.
- Updated `pyproject.toml` to include new dependencies: FastAPI, Uvicorn, and others.
- Modified example quickstart to use the new FastAPI environment.
- Created a user interface for the playground with React components for form submission and result display.
- Implemented CORS middleware for API accessibility from different origins.

Author: lakshyaag

examples/quickstart.py

@@ -12,10 +12,10 @@
 rlm = RLM(
     backend="openai",  # or "portkey", etc.
     backend_kwargs={
-        "model_name": "gpt-5-nano",
+        "model_name": "openai/gpt-4.1-mini",
         "api_key": os.getenv("OPENAI_API_KEY"),
     },
-    environment="local",
+    environment="modal",
     environment_kwargs={},
     max_depth=1,
     logger=logger,

playground/__init__.py

@@ -0,0 +1,2 @@
+"""RLM Playground - FastAPI server for running RLM completions via web interface."""
+

playground/models.py

@@ -0,0 +1,46 @@
+"""Pydantic models for RLM playground API requests and responses."""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+ClientBackend = Literal["openai", "portkey", "openrouter", "vllm", "litellm", "anthropic"]
+EnvironmentType = Literal["local", "prime", "modal"]
+
+
+class RunRequest(BaseModel):
+    """Request model for running RLM completion."""
+
+    prompt: str | dict[str, Any] = Field(..., description="Main prompt/context for the RLM")
+    root_prompt: str | None = Field(None, description="Optional root prompt visible to the root LM")
+    backend: ClientBackend = Field("openai", description="LM provider backend")
+    backend_kwargs: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Backend-specific configuration (model_name, api_key, etc.)",
+    )
+    environment: EnvironmentType = Field("local", description="Execution environment type")
+    environment_kwargs: dict[str, Any] = Field(
+        default_factory=dict, description="Environment-specific configuration"
+    )
+    max_iterations: int = Field(30, ge=1, le=100, description="Maximum number of RLM iterations")
+    max_depth: int = Field(
+        1, ge=0, le=1, description="Maximum recursion depth (currently only 0 or 1)"
+    )
+    other_backends: list[ClientBackend] | None = Field(
+        None, description="Additional backends for sub-calls"
+    )
+    other_backend_kwargs: list[dict[str, Any]] | None = Field(
+        None, description="Configuration for additional backends"
+    )
+    enable_logging: bool = Field(False, description="Whether to save logs to file")
+
+
+class RunResponse(BaseModel):
+    """Response model for RLM completion result."""
+
+    success: bool = Field(..., description="Whether the completion succeeded")
+    response: str | None = Field(None, description="Final answer from RLM")
+    root_model: str | None = Field(None, description="Model name used")
+    execution_time: float | None = Field(None, description="Total execution time in seconds")
+    usage_summary: dict[str, Any] | None = Field(None, description="Token usage summary per model")
+    error: str | None = Field(None, description="Error message if completion failed")

playground/run.py

@@ -0,0 +1,19 @@
+"""CLI entry point for running the RLM playground FastAPI server."""
+
+import sys
+from pathlib import Path
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "playground.server:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+    )

playground/server.py

@@ -0,0 +1,119 @@
+"""FastAPI server for RLM playground."""
+
+import os
+
+from dotenv import load_dotenv
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from rlm import RLM
+from rlm.logger import RLMLogger
+
+from playground.models import RunRequest, RunResponse
+
+# Load environment variables
+load_dotenv()
+
+# Create FastAPI app
+app = FastAPI(
+    title="RLM Playground API",
+    description="API for running RLM completions via web interface",
+    version="0.1.0",
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:3000",  # Next.js dev server
+        "http://localhost:3001",  # Alternative Next.js port
+        "http://127.0.0.1:3000",
+        "http://127.0.0.1:3001",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+def root():
+    """Health check endpoint."""
+    return {"status": "ok", "message": "RLM Playground API"}
+
+
+@app.post("/api/run", response_model=RunResponse)
+def run_rlm(request: RunRequest) -> RunResponse:
+    """
+    Run an RLM completion with the provided configuration.
+
+    This endpoint creates an RLM instance, runs a completion, and returns the result.
+    """
+    try:
+        # Setup logger if enabled
+        logger = None
+        if request.enable_logging:
+            log_dir = os.getenv("RLM_LOG_DIR", "./logs")
+            logger = RLMLogger(log_dir=log_dir)
+
+        # Create RLM instance
+        rlm = RLM(
+            backend=request.backend,
+            backend_kwargs=request.backend_kwargs or {},
+            environment=request.environment,
+            environment_kwargs=request.environment_kwargs or {},
+            max_depth=request.max_depth,
+            max_iterations=request.max_iterations,
+            other_backends=request.other_backends,
+            other_backend_kwargs=request.other_backend_kwargs,
+            logger=logger,
+            verbose=False,  # Disable console output in API
+        )
+
+        # Run completion
+        result = rlm.completion(
+            prompt=request.prompt,
+            root_prompt=request.root_prompt,
+        )
+
+        # Extract response - handle both string and tuple (type, content) formats
+        response_text = result.response
+        if isinstance(response_text, tuple):
+            # If it's a tuple from find_final_answer, extract the content
+            # Format: (type, content) where type is "FINAL" or "FINAL_VAR"
+            answer_type, answer_content = response_text
+            if answer_type == "FINAL":
+                # For FINAL, use the content directly
+                response_text = answer_content.strip().strip('"').strip("'")
+            elif answer_type == "FINAL_VAR":
+                # For FINAL_VAR, the content is the variable name
+                # We can't look it up here since we don't have access to the environment
+                # So we'll return a message indicating the variable name
+                variable_name = answer_content.strip().strip('"').strip("'")
+                response_text = f"[FINAL_VAR: {variable_name}]"
+            else:
+                # Fallback: just use the content
+                response_text = (
+                    answer_content if isinstance(answer_content, str) else str(answer_content)
+                )
+
+        # Convert result to response
+        return RunResponse(
+            success=True,
+            response=str(response_text) if response_text else None,
+            root_model=result.root_model,
+            execution_time=result.execution_time,
+            usage_summary=result.usage_summary.to_dict(),
+            error=None,
+        )
+
+    except Exception as e:
+        # Return error response
+        return RunResponse(
+            success=False,
+            response=None,
+            root_model=None,
+            execution_time=None,
+            usage_summary=None,
+            error=str(e),
+        )

pyproject.toml

@@ -19,13 +19,14 @@ dependencies = [
 
 [project.optional-dependencies]
 modal = ["modal>=0.73.0", "dill>=0.3.7"]
+playground = ["fastapi>=0.115.0", "uvicorn[standard]>=0.32.0", "pydantic>=2.0.0"]
 
 [build-system]
 requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools.packages.find]
-include = ["rlm", "rlm.*"]
+include = ["rlm", "rlm.*", "playground"]
 
 [dependency-groups]
 dev = [