Documentation

Start here

In the cloud

Open the app and create a free account — nothing to install. To switch the assistant on, add your own AI provider key in Settings → AI. You pay the provider directly; there is no markup on tokens.

On your own server

The whole stack runs on Docker Compose: Postgres, Redis, Meilisearch, MinIO, SearXNG, the real-time collaboration server, the MCP server and two code sandboxes. The instance owner has no plan limits at all.

git clone https://github.com/iezhik87/sinoutX.git
cd sinoutX
cp .env.example .env   # fill in the values
docker compose up -d

Deployment details live in DEPLOY.md.

Account & security

The first user to register becomes the instance owner (OWNER). After that, registration follows one of three modes the owner picks in the admin panel: open, invite-only, or closed.

Two-factor authentication (TOTP) is enabled in Settings → Security: the app shows a QR code, and once you confirm with a code, 2FA becomes mandatory at sign-in. Login is brute-force protected — five failed attempts lock that email + IP pair for 15 minutes.

Workspace & projects

Every user has one personal workspace, created automatically at sign-up. It holds your settings, the assistant's memory and your personal modules. Projects live inside it, and collaboration happens by sharing a single project rather than by spinning up extra workspaces.

The Inbox project is created for you and serves as the quick-capture bucket: anything the assistant cannot attach to a specific project lands there. It is a system project, so it does not count against your plan's project limit.

Modules are projects too — just flagged as such, with registries instead of pages.

Pages & editor

The editor is block-based: headings, lists, checklists, tables, code, quotes, images, attachments and links between pages. Pages nest into a tree.

Real-time collaboration runs through a dedicated server (Hocuspocus/Yjs): text syncs live and you see your co-authors' cursors.

Version history is stored separately — any version can be previewed and restored.

Export a page or a whole project to md, docx, pdf or zip; the budget exports to csv.

Tasks

Statuses: TODO, IN_PROGRESS, REVIEW, DONE, CANCELLED. Priorities: LOW, MEDIUM, HIGH, URGENT.

Views: list, board (drag-and-drop kanban), Gantt chart, burndown chart, time tracker. There are subtasks, tags, comments, custom fields and automation rules.

Recurring tasks. A task can carry a recurrence rule. When the original is closed, the scheduler spawns the next one and retires the original, so duplicates never pile up.

Reminders are a list of moments in time and arrive both in the app and in Telegram.

Search your base

Search has two layers. Meilisearch handles instant full-text search across pages, tasks, notes and recognized files. On top sits a semantic layer built on embeddings — it finds things by meaning, even when the exact words never appear in the text.

The index is rebuilt on every server start; a manual reindex lives in Settings → Backup → Reindex.

Canvas & knowledge graph

The Vision Board is an infinite canvas: sticky notes, notes, images and links between nodes. The assistant can create canvases and add nodes to them.

The knowledge graph is built from the links between pages, notes, tasks and sources — and shows you what connects to what.

Assistant & AI keys

The assistant lives in the app and in Telegram. It does not advise, it acts: it creates pages and tasks, writes records into registries, searches the web, counts calories and balances, reminds you and sends morning briefs.

BYOK — the keys are yours. Add a provider key in Settings → AI; the model is chosen per user. There is no markup on tokens: you pay the provider directly.

Supported providers:

Each provider accepts a custom Base URL, so any OpenAI-compatible endpoint plugs in — a local LM Studio, your own proxy, a self-hosted gateway. Local models need no key at all.

Under the hood the assistant carries more than seventy tools, grouped like this:

Some tools sit behind capability gating and cannot be called without the matching right:

Web research

The instance runs its own SearXNG — a meta-search engine aggregating Google, Bing, DuckDuckGo and others. Your queries never feed someone else's analytics.

The assistant does not just search: it carries the result all the way into your base. It reads the pages it found, saves them as sources and links them to the project page.

Project templates

A template is not an empty shell but a script: the assistant builds the page and task structure, gathers sources and writes the content. Built-in templates:

Your own templates are saved from a finished project or page and then applied in one click.

Skills & custom tools

A skill is a recurring, scheduled action the assistant sets up for itself when you ask: a morning brief, a weekly finance report, a reminder to redo your lab tests. It is managed with create_skill, list_skills and delete_skill, and requires the assistant_full capability.

Custom tools. Any HTTP API can be wrapped into a tool the assistant calls just like a built-in one. Usually the AI assembles it from your description: “call this endpoint, here is the key, return the exchange rate.” The definition is stored in the workspace settings, keys are encrypted, and requests go through an SSRF guard and a timeout.

Code sandbox

The execute_code tool runs Python or bash in a separate container, never inside the backend. There are two containers, and the difference matters:

Modules & registries

A module is a vertical extension: a set of registries (Collections) with a ready schema, views and hints for the assistant. Install and remove them in one click under Modules.

A registry is a table with typed fields. The available types:

A relation field points at records in another registry. A secret field is encrypted at rest, masked in the UI and excluded from search and from the assistant's memory.

Each registry is shown through one of these views: table, form, chart, board, calendar, gallery.

Schema updates. On every server start, installed modules are re-synced with their manifest: new fields, registries and views appear. Your records are never touched.

Custom modules. The instance owner can import their own manifest — from a file or a URL — and it shows up in the shared catalog.

Medical Record

A personal medical archive. Registries: profile, lab results, indicators, visits, conditions, medications, measurements, nutrition, studies, documents.

Measurements hold blood pressure, pulse, glucose, oxygen saturation, temperature, weight, steps, calories and BMI. Nutrition computes calories and macros — just tell the assistant “chicken salad 250 g for lunch”.

Document recognition. The medical-scan pipeline reads a photo or PDF of a lab result and lays the indicators out row by row, together with their reference ranges — out-of-range values are highlighted.

The whole record exports to a single PDF.

Finance

Registries: accounts, transactions, budget. Expenses, income and transfers between accounts are all supported.

Currency exchange. A transfer carries the debited amount, the credited amount and the rate — so exchanging between accounts in different currencies uses your rate, not someone else's reference table.

Receipt recognition. The receipt-scan pipeline reads a photo of a receipt, works out the merchant, the total and the category, and logs the expense.

The assistant does not do balance arithmetic in its head. It has a dedicated finance_overview tool that returns computed balances, the month's cash flow and plan-versus-actual. This matters: language models get arithmetic wrong, so the numbers arrive already calculated.

Vault

Passwords, cards and arbitrary secrets. Registries: logins, cards, secrets.

Fields of type secret are encrypted at rest with the instance key. Lists show them masked; a value is only returned when you explicitly ask for that one field.

Retrieval in Telegram. Ask the bot for “the gmail password” — it sends the value and deletes its own message a minute later. That message is never stored in the conversation history.

Bitwarden import. Export your vault as unencrypted JSON and upload it on the module page: logins, cards and secure notes are sorted into the registries, and secret fields are encrypted on write.

Memory

This module keeps the assistant's long-term memory in a compact shape: a core (who you are and what matters to you), facts, entities and episodes. Memory survives a conversation restart and works in the app, in Telegram and in external agents over MCP.

The assistant fills it with the remember and recall tools, and consolidation folds accumulated episodes into durable facts.

Personal Growth

Habits with check-ins, goals in the OKR shape with key results, and a journal. The assistant can create a habit, tick it off, set an objective and write a journal entry — straight from the chat, without opening the UI.

Messengers: Telegram & Viber

Telegram

The bot becomes a full remote control for the assistant. Three steps to connect: create a bot with @BotFather, paste the token into Settings → Integrations, press Connect.

What it handles: text, forwarded photos and PDFs (recognized), voice messages (transcribed), a live “typing…” indicator that names the current step, formatted answers, and action buttons under tasks.

Viber

A second channel for the same assistant. Create the bot at partners.viber.com, paste the token into Settings → Integrations → Viber; instead of /start you subscribe to the bot, which is how it learns where to write.

Everything else is the same: notes and tasks, photo and PDF recognition, action buttons, reminders and morning briefs. The commands /tasks, /today, /balance, /new, /help are understood as plain text.

What Viber cannot do, and how that shows:

• No “typing…” indicator, no message editing — there is no live progress line; the answer arrives in one piece.
• A sent message cannot be deleted — so Vault secret retrieval is removed from the agent's toolset on Viber: a secret that cannot be recalled must never reach the chat.
• Files can only be sent as a public URL — exporting a project as a document works on Telegram.

Connect Claude (MCP)

SinoutX ships a built-in MCP server, so an external agent — Claude Desktop, for instance — can read and write your workspace as long-term memory. Create a key in Settings → API Keys and add it to claude_desktop_config.json:

{
  "mcpServers": {
    "sinout": {
      "command": "npx",
      "args": ["-y", "mcp-remote",
        "https://app.sinout.dasp.top/mcp",
        "--header", "x-api-key:sk_sinoutx_your_key"]
    }
  }
}

After a restart the sinout_* tools appear: pages, tasks, events, notes, budget, registries, memory, graph, search and file upload. There is also sinout_init_agent, which pulls in the instructions and registries so the agent immediately knows where things belong.

API & keys

Everything the UI does is available through a REST API under /api/v1. Create a personal key in Settings → API Keys and pass it in the x-api-key header. A key can carry an expiry date and a scope.

Interactive API docs, listing every endpoint, are served at /docs on your instance.

curl https://app.sinout.dasp.top/api/v1/projects \
  -H "x-api-key: sk_sinoutx_your_key"

Import & export

Import lives in Settings → Import: a Notion ZIP export (Markdown & CSV, or HTML) and an Obsidian vault ZIP. The page hierarchy is preserved.

Export: a page or a project to md, docx, pdf and zip; the budget to csv; a whole module to PDF. The assistant can send an export as a file straight into Telegram.

Backup & restore

The user backup (Settings → Backup) downloads a ZIP with everything you own: projects, pages, tasks, notes, events, budget, attachments and links. Restoring adds what is missing without deleting what is already there.

The admin backup captures the whole instance, database and object storage included. You configure a schedule and the disk the archives land on.

Collaboration

You share a project, not a workspace. An invited person gets one of two roles:

Pages are edited simultaneously and co-author cursors are visible live.

Admin & monitoring

Owners and admins get user management, the registration mode, an audit log, license keys, module import, and the ability to grant capabilities to a specific user (the gating described in the assistant section).

Monitoring shows who is online right now, CPU and memory load, network, disks, an hour of history and configurable alerts when a threshold is crossed.

Quotas. For each user you see the space used and the limit; uploads are blocked once it runs out. The limit can be overridden on top of the plan.

Pricing

Nobody is charged for rows in a database. Projects, pages, notes, tasks, registries and modules are unlimited on every plan: they cost us nothing, and charging for them would punish you for using the product. You pay only for what has a real cost.

Space is bought, not metered. A pack is 200 MB for $0.60 a month, charged the moment you take it and every month you hold it. When the space runs out, uploads stop — what you already uploaded stays where it is and remains readable. You may release a pack whenever your files still fit into what is left: nobody is going to delete them for you.

One wallet. Hosting, disk, people and tokens are all drawn from the same balance, topped up with crypto. Bringing your own AI key silences the token meter for good — that is what "0% markup" means.

What tokens cost. On the built-in model: $0.65 per 1M input tokens and $1.31 per 1M output (cached input is far cheaper). In human terms a typical answer costs a fraction of a cent, and an active month rarely exceeds a couple of dollars. With your own key we do not meter tokens at all.

Collaboration. You invite teammates by email into shared projects. Each has their own separate account — nobody shares one seat. There is no per-seat fee: each account is an ordinary user with his own $5/mo subscription and his own balance (or his own key). Inviting is free; you pay for yourself, your teammate for himself. On your own server, the Team licence unlocks collaboration.

A new cloud account starts frozen. Notes, search and export work, but to create and upload you must top up. The first top-up settles the month and lifts the freeze at once. The minimum top-up is $15.

The Team licence is perpetual. The payment buys a year of updates, not the right to keep using what you already run. Let it lapse and everything keeps working; it simply stops updating.

A spend cap. The built-in model has a monthly ceiling (default $20). It protects you, not us: an agent stuck in a tool loop overnight can burn a budget in an hour.

An unpaid cloud month freezes writing, not your data. Reading, search and export keep working, and a top-up restores everything at once. The instance owner and admins are never billed and never frozen. On your own server there is no monthly bill at all.

Privacy

Your data sits on your server, in your database. The assistant runs on your AI key: the request goes straight to the provider you picked, with no markup on tokens. Want no external services at all? Plug in a local model through Ollama.

Web search goes through your own SearXNG rather than a search engine that keeps your analytics. Vault secrets are encrypted at rest and excluded from indexing and from memory. Every meaningful action is written to the audit log.

More: Privacy policy · Terms