ROK is the AI workspace for work you want to keep yours.

Getting Started

Use this as the shortest path to understanding how ROK is meant to be used.

Core Surfaces

How ROK Works

Privacy and Storage

ROK's privacy model is about disclosure and choice. Local-first does not mean every deployment is offline; it means you should be able to tell what stays here, what leaves the device, and why.

FAQ

Is ROK fully offline?

No. Hosted providers, remote endpoints, and tunnels still require network access. Use a local runtime when you want requests to stay on your machine, and treat hosted deployments as networked environments.

Where are my chats stored by default?

On this browser, on this device, using local storage unless you build a different persistence layer around it.

What is the main difference between chat and ROK CODE?

Chat is for discussion and reasoning. ROK CODE is for file-based work where the assistant proposes concrete code changes that you can review before applying.

Can I switch models per session?

Yes. Model selection is part of the session experience and is remembered locally on the current device.

Roadmap

• Sharper workspace identity: make the product feel more like one serious workstation.
• Stronger privacy controls: clearer runtime badges, better disclosure, and safer local storage defaults.
• Cleaner onboarding: better setup guidance for local, hosted, and mixed deployments.
• Community-ready foundations: make self-hosting and user-controlled setups easier to understand and trust.

API Access

ROK exposes an API for external integrations. During beta, API keys are manually reviewed. Use your key in X-ROK-API-Key when you are not already in a trusted browser session.

Keys can include request caps. When a key reaches its assigned limit, protected endpoints can return 429 with {"error":"API key request limit exceeded"}.

Main Endpoints

/api/chat Request Body

Authentication Errors

Code Examples

async function runRokChat() {
  const response = await fetch("https://rokbackendreal.kyklos.online/api/chat", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Accept": "text/event-stream",
      "X-ROK-API-Key": "YOUR_KEY"
    },
    body: JSON.stringify({
      message: "Summarize this error log in 3 bullets.",
      history: []
    })
  });

  if (!response.ok) throw new Error(`Request failed (${response.status})`);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let pending = "";

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    pending += decoder.decode(value, { stream: true });
    const blocks = pending.split("\\n\\n");
    pending = blocks.pop() || "";

    for (const block of blocks) {
      for (const line of block.split("\\n")) {
        if (!line.startsWith("data:")) continue;
        const payload = JSON.parse(line.slice(5).trim());
        if (typeof payload.token === "string") {
          console.log(payload.token);
        }
      }
    }
  }
}

import json
import requests

with requests.post(
    "https://rokbackendreal.kyklos.online/api/chat",
    headers={
        "Content-Type": "application/json",
        "Accept": "text/event-stream",
        "X-ROK-API-Key": "YOUR_KEY",
    },
    json={"message": "Explain this stack trace.", "history": []},
    stream=True,
    timeout=(10, 300),
) as response:
    response.raise_for_status()
    for raw_line in response.iter_lines(decode_unicode=True):
        if not raw_line or not raw_line.startswith("data:"):
            continue
        payload = json.loads(raw_line[5:].strip())
        token = payload.get("token", "")
        if token:
            print(token, end="", flush=True)

curl -N -X POST "https://rokbackendreal.kyklos.online/api/chat" \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -H "X-ROK-API-Key: YOUR_KEY" \
  -d '{"message":"Refactor this function and explain why.","history":[]}'

Tool Calling

ROK supports client-side tool calling in an OpenAI-style function format. The model can suggest a tool call, but your client is responsible for executing that tool and sending the result back through conversation history.

The backend does not execute your custom tools for you. It emits tool call suggestions and leaves execution to the caller.

Basic Flow

1. Send /api/chat with a tools array.
2. Parse any emitted tool_calls event from the SSE stream.
3. Run the tool locally in your own client application.
4. Send a follow-up request with the tool result included in history.

Tool Definition

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {"type": "string"}
      },
      "required": ["location"]
    }
  }
}

SSE Event Example

data: {"tool_calls":[{"id":"call_abc123","type":"function","function":{"name":"get_weather","arguments":"{\"location\":\"NYC\"}"}}],"assistant_content":""}

Follow-Up History Example

{
  "message": "",
  "history": [
    {"role": "user", "content": "What's the weather in NYC?"},
    {"role": "assistant", "content": "", "tool_calls": [
      {"id": "call_abc123", "type": "function", "function": {"name": "get_weather", "arguments": "{\"location\":\"NYC\"}"}}
    ]},
    {"role": "tool", "name": "get_weather", "tool_call_id": "call_abc123", "content": "{\"temp\":72,\"condition\":\"sunny\"}"}
  ],
  "tools": [ ... ]
}

Limits

Contributing

Good contributions are focused, testable, and tied to the actual product direction. That usually means docs improvements, reproducible bug reports, UX cleanup, or scoped feature work that strengthens the workspace.

• Start small and make the change easy to evaluate.
• When changing behavior, explain the user-facing impact clearly.
• When proposing architecture shifts, describe the migration cost and why it is worth it.