open-dots: Open Source Data Extraction & Web Scraping

What is open-dots?

Open Dots is a self-hosted, MIT-licensed AI workspace for developers and individuals who want chat, tool use, approval workflows, connectors and an optional computer runtime to run locally under their own control, positioned as an open-source alternative to OpenAI Dots.

What it is

Open Dots pairs a Python/FastAPI server with a Next.js web client, bringing model conversations, a governed action gateway, approval prompts and an optional isolated browser runtime into one local-first application. Application state lives in SQLite under a data directory (default ~/.open-dots), provider credentials are encrypted at rest, and models are reached through a bundled inference adapter rather than a fixed provider. The project is independently built and is not affiliated with or endorsed by OpenAI, xAI or any model provider.

Hosted AI workspaces keep conversations, credentials and action history on someone else's infrastructure, and higher-risk actions can proceed without a visible gate. Open Dots replaces that arrangement for people who would rather run the workspace themselves: conversations persist locally, workspace reads and writes are confined to a declared root, and higher-risk actions pause for approval while producing audit events. The registry lists it under Data & Analytics / Data Extraction & Web Scraping.

Key capabilities

Create assistant personas, each with separate instructions, model IDs and visual identities.
Stream chat responses, persist conversations locally, render Markdown, attach images and dictate messages where the browser supports speech input.
Reach models through the bundled inference adapter, which sends prediction requests to {MODEL_API_BASE_URL}/{model_id} and uploads images to {MODEL_API_BASE_URL}/upload_file; DEFAULT_MODEL defaults to gpt-5-mini.
Route workspace reads, writes and computer actions through a deny-by-default gateway bounded by WORKSPACE_ROOT; higher-risk actions pause for approval and emit audit events.
Connect apps through Composio with explicit OAuth, including narrow GitHub issue lookup and create actions.
Run an optional bot-scoped Docker/Playwright computer runtime, or set COMPUTER_PROVIDER to fake, docker or remote.
Keep state in SQLite and encrypt provider credentials at rest, with an optional Fernet APP_ENCRYPTION_KEY and a bearer APP_AUTH_TOKEN for direct or non-loopback API access.

Who uses it and how

Individual developers running it on a laptop for local experimentation, the use the project's own status note names as its target.
Builders who point it at their own inference host by setting MODEL_API_KEY and MODEL_API_BASE_URL against a service implementing the adapter's request and response contract.
People who need a visible approval step before an agent touches a workspace or operates a computer, rather than an unconditional action loop.
Self-hosters who want conversations, credentials and audit events to stay in local SQLite storage under DATA_DIR.

Getting started

Clone the repository, create a Python 3.10+ virtual environment in server/, install requirements.txt, export MODEL_API_KEY and MODEL_API_BASE_URL, and start the API with python run.py on http://127.0.0.1:8000; then run npm install and npm run dev in client/ and open http://localhost:3000. The provider key can instead be entered in App Settings, and the server generates its local session and encryption keys on first start.

How it compares

Open Dots is positioned against OpenAI Dots as a self-hostable, MIT-licensed alternative; the contrasts the facts support concern licence, hosting and data ownership rather than feature parity. Where the hosted product is operated for the user, Open Dots runs on the user's own machine or server, keeps state in local SQLite, encrypts provider credentials at rest, and lets the operator choose the inference host and models. It is free and open source to licence, but the operator supplies the inference API key and base URL, plus any connector or computer-runtime setup.

When to use it — and when not to

A self-hoster has to run both halves of the stack, the FastAPI API and the Next.js client, plus an inference service implementing the adapter contract and optionally a Composio key or Docker/Playwright runtime. The project describes itself as a prototype in active development and states that multi-user hosting and hostile-web isolation are not production ready, so anyone needing production-grade multi-tenant deployment or hardened isolation from untrusted web content should look elsewhere. The bundled adapter also does not implement the generic OpenAI-compatible chat completions interface, which rules it out for some inference setups.

project readme (upstream, from github) — read inline

Open Dots: Open-Source Alternative to OpenAI Dots

▶ Watch: OpenAI Dots Alternative: Free, Open Source & Any Model

Open Dots is an open-source alternative to OpenAI Dots: a self-hosted AI workspace for chat, tool use, approvals, connectors, and computer tasks. It brings model conversations, a governed action gateway, approval prompts, and an optional isolated browser runtime into one local-first app.

Open Dots is independently built and is not affiliated with or endorsed by OpenAI, xAI, or any model provider. It offers a self-hostable, inspectable alternative for people looking for an open-source OpenAI Dots alternative, with local data and explicit approval for higher-risk actions.

Status: Prototype / active development. Intended for local experimentation; multi-user hosting and hostile-web isolation are not production ready.

What it does

Create assistant personas with separate instructions, model IDs, and visual identities.
Stream chat responses, persist conversations locally, render Markdown, attach images, and dictate messages where the browser supports speech input.
Connect to models through the included inference adapter and choose from its configured model catalog.
Request confined workspace reads and writes or computer actions through a deny-by-default gateway. Higher-risk actions pause for approval and produce audit events.
Connect apps through Composio, with explicit OAuth and narrow GitHub issue lookup/create actions.
Run an optional bot-scoped Docker/Playwright computer runtime or connect a compatible remote computer service.
Keep application state in SQLite and encrypt provider credentials at rest.

Why Open Dots

Open Dots gives developers and individuals a self-hosted AI workspace they can inspect and adapt. Use it as an open-source alternative to OpenAI Dots when you want local-first conversation storage, configurable model access, visible approval steps, and an optional computer runtime under your control. It is a separate project with its own implementation and current limitations; see the provider and runtime notes below before deploying it.

Quick start

Requirements

Node.js and npm
Python 3.10+ and pip
An inference API key and base URL for live model responses

Clone and start the API:

git clone https://github.com/Anil-matcha/open-dots.git
cd open-dots/server
python -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
export MODEL_API_KEY="your_api_key"
export MODEL_API_BASE_URL="https://your-inference-host.example/api/v1"
python run.py

The API is available at http://127.0.0.1:8000; interactive docs are at /docs.

In a second terminal, start the web client:

cd open-dots/client
npm install
npm run dev

Open http://localhost:3000. You can enter the provider key in App Settings instead of setting the environment variable. The server creates local session and encryption keys under its data directory on first start.

Model provider

The bundled inference adapter sends a prediction request to {MODEL_API_BASE_URL}/{model_id} and uploads images to {MODEL_API_BASE_URL}/upload_file. Configure it with a service that implements this request and response contract and supports the model IDs you select. This adapter does not implement the generic OpenAI-compatible chat completions interface.

Variable	Default	Purpose
`MODEL_API_KEY`	empty	Provider key fallback when no key is saved in settings
`MODEL_API_BASE_URL`	empty	Required base URL for the configured inference API
`DEFAULT_MODEL`	`gpt-5-mini`	Initial model for new assistants
`COMPOSIO_API_KEY`	empty	Optional connector credential
`DATA_DIR`	`~/.open-dots`	SQLite state and local keys
`APP_ENCRYPTION_KEY`	generated in `DATA_DIR`	Optional Fernet key for encrypted credentials
`APP_AUTH_TOKEN`	generated in `DATA_DIR`	Bearer token for direct or non-loopback API access
`WORKSPACE_ROOT`	project root	Directory boundary for approved workspace actions
`COMPUTER_PROVIDER`	`fake`	Computer provider: `fake`, `docker`, or `remote`
`HOST` / `PORT`	`127.0.0.1` / `8000`	API bind address

For non-loopback access, set APP_AUTH_TOKEN, configure the client with NEXT_PUBLIC_API_TOKEN, use HTTPS, and set a narrow CORS_ORIGINS list. Do not expose generated tokens in logs or source control.

Optional computer runtime

The default fake adapter is for local development and deterministic behavior. To enable the Docker/Playwright computer provider:

docker build -t open-dots-computer:1.62.1 ./runtime
export COMPUTER_PROVIDER=docker
export COMPUTER_DOCKER_IMAGE=open-dots-computer:1.62.1

The daemon must be running. Containers use a separate workspace per assistant, a read-only root filesystem, dropped capabilities, and resource limits. Computer navigation and other higher-risk operations go through the action gateway and approval flow. This is not a hardened sandbox for hostile websites; review network egress, image provenance, and credential exposure before using it with untrusted content.

For a remote computer service, configure COMPUTER_PROVIDER=remote and the COMPUTER_REMOTE_* variables in server/app/config.py.

Architecture

Next.js client ── HTTP + SSE ── FastAPI API
                                  ├── SQLite + encrypted settings
                                  ├── configurable inference adapter
                                  ├── Composio connector adapter
                                  └── action gateway + approvals + audit
                                        ├── confined workspace tools
                                        └── fake / Docker / remote computer

The main code areas are client/ (Next.js UI), server/app/routers/ (HTTP API), server/app/services/ (providers, persistence, approvals, and tools), and runtime/ (Docker computer driver).

Current limitations

One local owner; user provisioning, roles, and multi-user grants are not implemented.
SQLite is local state; coordinated multi-instance storage and backup workflows are not included.
The bundled inference adapter expects a specific prediction API contract; a generic provider plugin interface is not implemented.
The computer runtime is opt-in and is not a hardened security boundary for arbitrary web content.
Connector actions are intentionally narrow; arbitrary tool discovery and writes are not implemented.
There is no mobile or desktop client, durable memory service, or scheduled routine engine.

Contributing

Issues and pull requests are welcome. Keep the documentation aligned with behavior, avoid committing credentials or local transcripts, and describe API or persistence changes clearly.

License

MIT. See LICENSE.

Frequently asked questions

Is open-dots free to use?

open-dots is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does open-dots do?

Open-source alternative to OpenAI Dots: self-hosted AI chat, tools, approvals, connectors, and computer tasks.

What is open-dots written in?

open-dots is primarily written in Python. Its source is publicly available at https://github.com/Anil-matcha/open-dots, and it has 4,834 GitHub stars.