Sliqtly Personal · Linux, macOS, Docker

Run Sliqtly locally.

The Personal server runs on your own computer: the MCP endpoint your agent writes presentations through, and a viewer that plays them in your browser. It runs as a background service and keeps the presentations on your own disk: data stays between your machine and your agent. Out of the box only your own computer can connect.

Advantages of running locally

Responsibilities for local users

1. Install

Ubuntu and Debian

Download (.deb, amd64) ARM (arm64)

curl -fLo /tmp/sliqtly-personal.deb https://sliqtly.com/download/sliqtly-personal_amd64.deb
sudo apt install /tmp/sliqtly-personal.deb

On an ARM computer (a Raspberry Pi with a 64-bit system, an ARM laptop) take sliqtly-personal_arm64.deb. The service starts right away and again at every boot.

macOS (Homebrew)

brew install terotests/sliqtly/sliqtly
brew services start sliqtly         # now and at every login

Apple silicon and Intel Macs both work. The Homebrew package is the full install: besides the viewer it has the editor, at http://localhost:8080/, and the presentations are listed at /decks.

Docker

docker run -d --name sliqtly --restart unless-stopped \
  -p 127.0.0.1:8080:8080 \
  -v sliqtly-data:/data -v sliqtly-backup:/backup \
  ghcr.io/terotests/sliqtly-personal:latest

The image runs on linux/amd64 and linux/arm64, so Docker Desktop on a Mac or Windows works too. The presentations are in the sliqtly-data volume and survive updates. 127.0.0.1 in -p keeps it to this computer; see Networks before you change it.

Inside the container the server cannot tell this computer from others, so it always asks for its access token. Without -e SLIQTLY_TOKEN=… it makes its own: docker logs sliqtly shows it and the link to open once in your browser (http://localhost:8080/?token=…). Your agent sends it as Authorization: Bearer ….

Then open http://localhost:8080/: the page lists your presentations, and each one plays in the viewer.

2. Connect your agent

The MCP endpoint is http://localhost:8080/mcp.

Claude Code

claude mcp add --transport http sliqtly http://localhost:8080/mcp

Cursor (~/.cursor/mcp.json)

{
  "mcpServers": {
    "sliqtly": { "url": "http://localhost:8080/mcp" }
  }
}

VS Code (.vscode/mcp.json)

{
  "servers": {
    "sliqtly": { "type": "http", "url": "http://localhost:8080/mcp" }
  }
}

Claude Desktop: not under Settings → Connectors, but in its config file (Settings → Developer → Edit Config, i.e. ~/Library/Application Support/Claude/claude_desktop_config.json on macOS, %APPDATA%\Claude\claude_desktop_config.json on Windows). Desktop starts the bridge mcp-remote as a program on your computer, so it needs Node.js. Restart Desktop after saving.

{
  "mcpServers": {
    "sliqtly": { "command": "npx", "args": ["-y", "mcp-remote", "http://localhost:8080/mcp"] }
  }
}

Without an MCP client: from a script

An agent that can only run code (a browser panel's JavaScript, a notebook) can call /mcp with plain HTTP POSTs. The server answers each call with one JSON object (Content-Type: application/json), not an event stream; a client must still accept both, as MCP's HTTP transport says. This helper reads either:

let session = "";
async function sliqtly(method, params = {}) {
  const res = await fetch("http://localhost:8080/mcp", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Accept: "application/json, text/event-stream",
      ...(session ? { "Mcp-Session-Id": session } : {}),
    },
    body: JSON.stringify({ jsonrpc: "2.0", id: Date.now(), method, params }),
  });
  session = res.headers.get("Mcp-Session-Id") || session;
  const text = await res.text();
  const json = (res.headers.get("Content-Type") || "").includes("text/event-stream")
    ? text.split("\n").filter((l) => l.startsWith("data:")).pop().slice(5)
    : text;
  const answer = JSON.parse(json);
  if (answer.error) throw new Error(answer.error.message);
  return answer.result;
}
await sliqtly("initialize", { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "script", version: "1" } });
const guide = await sliqtly("tools/call", { name: "sliqtly_guide", arguments: {} });
// then create_presentation, render_slide (its picture is result.content[i].data, base64 PNG), …

claude.ai, the mobile apps and Desktop's Connectors

A custom connector added in claude.ai (Customize → Connectors) is called from Anthropic's cloud, not from your computer, and its address must start with https://. http://localhost:8080/mcp is refused there, and would not be reachable anyway. The same goes for connectors in the mobile apps and in Claude Desktop's Settings → Connectors. ChatGPT works the same way.

The only way to use your own server from these apps is a public HTTPS tunnel to it, for example:

cloudflared tunnel --url http://localhost:8080   # prints https://<random>.trycloudflare.com
tailscale funnel 8080                           # https://<computer>.<tailnet>.ts.net

Then set SLIQTLY_URL to that address (e.g. SLIQTLY_URL=https://abc-def.trycloudflare.com, Docker: -e SLIQTLY_URL=…) and restart Sliqtly; without it the server refuses requests that come in under the tunnel's name. Add https://…/mcp as the connector. A quick Cloudflare tunnel gets a new address every time it starts, so both have to be changed each time.

A tunnel puts your server on the internet. claude.ai can send SLIQTLY_TOKEN only if your organization has connector request headers (a beta for a few organizations); otherwise leave the token unset, and anyone who learns the tunnel address can change and delete every presentation through /mcp. With the token set, the whole server needs it (/mcp, the pages, /api and /files); without it, all of them are open to anyone with the address. Run a tunnel only while you use it, keep nothing private on the server meanwhile, and prefer Claude Code, Desktop's config file or the hosted https://sliqtly.com/mcp.

3. Use the service

Ubuntu and Debian (systemd)

systemctl status sliqtly          # is it running, and since when
sudo systemctl restart sliqtly    # after changing the settings
sudo systemctl stop sliqtly       # stop it for now
sudo systemctl start sliqtly
sudo systemctl disable sliqtly    # do not start it at boot
sudo systemctl enable sliqtly     # start it at boot again
journalctl -u sliqtly -f          # follow its log

macOS (Homebrew)

brew services list                  # is it running
brew services restart sliqtly       # after changing the settings
brew services stop sliqtly          # stop it, and do not start it at login
brew services start sliqtly
tail -f "$(brew --prefix)/var/log/sliqtly.log"

Docker

docker ps --filter name=sliqtly     # is it running
docker restart sliqtly
docker stop sliqtly                 # stays stopped until docker start
docker start sliqtly
docker logs -f sliqtly

4. Choose the port

The server listens on 8080. To use 8090 instead:

InstallChangeThen
.debPORT=8090 in /etc/sliqtly/sliqtly.envsudo systemctl restart sliqtly
HomebrewPORT=8090 in $(brew --prefix)/etc/sliqtly/sliqtly.envbrew services restart sliqtly
Dockerthe left side of -p: -p 127.0.0.1:8090:8080remove the container and run it again (the volumes keep the presentations)

Then open http://localhost:8090/ and point your agent at http://localhost:8090/mcp. A port below 1024 needs extra rights; pick one above it. If the port is taken, the log says so and the server does not start.

All the settings

The same names go in sliqtly.env (.deb, Homebrew) or after -e in docker run.

SettingDefaultWhat it does
PORT8080The port the server listens on.
SLIQTLY_LISTENlocalWho can connect: local, wired or network; see Networks. Docker sets network inside the container and leaves the choice to -p.
SLIQTLY_ALLOWemptyWith wired or network: only these address ranges, e.g. 192.168.1.0/24. This computer is always let in.
SLIQTLY_TOKENemptyWhen set, the whole server needs it: agents send Authorization: Bearer <token>, a browser opens a page once with ?token=<token>. With wired or network and no token, the server makes its own; see Access token.
SLIQTLY_URLthe address a request came in onThe address in the links the server gives, e.g. http://my-pc.local:8080 or https://slides.example.com.
SLIQTLY_DATA.deb /var/lib/sliqtly
Homebrew $(brew --prefix)/var/sliqtly
Docker /data
Where the presentations are kept.
SLIQTLY_BACKUPthe same with -backup (Docker /backup)A daily backup of the presentations; empty turns it off.
SLIQTLY_IMPORT_DIRSemptyFolders your agent may take pictures and data files from by path; see Pictures from a folder.
SLIQTLY_MAX_FILE_MB50The most megabytes one picture or file may have, whether an agent sends it, it is read from an import folder or it is added in the editor or a room.

Pictures from a folder

An agent normally sends a picture to Sliqtly as a public web address or as base64 text inside the tool call. For pictures that are only on your computer, name the folders they are in when the server starts, comma separated:

SLIQTLY_IMPORT_DIRS=/Users/me/photoalbum

Then create_presentation and update_presentation also take a path for each picture or data file, e.g. {"name": "cover.jpg", "path": "/Users/me/photoalbum/trip/cover.jpg"}, and the server reads the file from disk. A picture or data file may be up to 50 MB (SLIQTLY_MAX_FILE_MB). Only files inside these folders are read: a path that leads out of them, through .. or a link, is refused. The tools offer path only when the setting is on; sliqtly.com never reads files by path.

5. Networks

The server decides which network interfaces it listens on. Pick the row that matches where other people are; the default, this computer only, needs nothing.

Who should connect.deb and HomebrewDocker
Only this computerSLIQTLY_LISTEN=local (the default). It listens on 127.0.0.1 and ::1 only, so on a café or hotel Wi-Fi nobody else sees it.-p 127.0.0.1:8080:8080
Computers on a wired LAN (office, home cable)SLIQTLY_LISTEN=wired. It listens on the Ethernet interfaces only and takes connections only from their subnets. Wi-Fi, phone tethering, VPNs and virtual interfaces stay closed, and plugging a cable in or out takes effect without a restart.-p 192.168.1.10:8080:8080, with this computer's LAN address
Computers on a Wi-Fi you trust (your home)SLIQTLY_LISTEN=network with SLIQTLY_ALLOW=192.168.1.0/24 (your home network's range). wired never opens Wi-Fi on purpose.as above, with the Wi-Fi address
The public internetDo not open the port directly. Put a reverse proxy with a real HTTPS certificate in front (below), keep Sliqtly on local, and set SLIQTLY_TOKEN.

Access token

Whenever other computers can connect (wired, network, Docker), or a token is set, every request needs the server's access token: the MCP endpoint, the pages, the presentations, their files and the live updates. Set your own:

SLIQTLY_TOKEN=a-long-random-secret      # e.g. from: openssl rand -hex 24

Without one, the server makes its own and keeps it in access-token in its data folder; the log shows it at every start, and the settings page on the server's own computer shows it too.

Links that work without the token: questionnaires and the viewing links of recordings, which carry their own unguessable key. On this computer only (local) and without a token nothing is asked.

Anyone with the token can read and change every presentation, so give it only to people you trust, and open the server only on a network you trust, never on a public Wi-Fi.

In Docker, the server sees connections through Docker's own network, so choose who reaches it with the -p address and the firewall rather than SLIQTLY_ALLOW.

On the internet, behind a proxy

For a server others reach over the internet, let a web server with a real certificate take the connections. With Caddy and a domain pointing at the machine, /etc/caddy/Caddyfile is:

slides.example.com {
    reverse_proxy 127.0.0.1:8080
}

and in sliqtly.env: SLIQTLY_LISTEN=local, SLIQTLY_URL=https://slides.example.com, SLIQTLY_TOKEN=…. Only ports 80 and 443 are then open to the internet; 8080 stays closed. The Personal license allows this for your own use, not as a service for another organization.

6. Firewall

With local nothing needs opening. When other computers connect, open the port only to the network they are on.

Ubuntu and Debian (ufw)

sudo ufw allow OpenSSH                                          # if you log in over SSH
sudo ufw allow from 192.168.1.0/24 to any port 8080 proto tcp   # your LAN only
sudo ufw enable
sudo ufw status numbered

Behind a proxy, open 80 and 443 (sudo ufw allow 80,443/tcp) and not 8080.

macOS

The firewall is in System Settings → Network → Firewall. With it on, macOS asks once whether sliqtly-server may accept incoming connections when the server first listens beyond this Mac; answer Allow on a network you trust. With local it never asks.

Docker

Docker's published ports go around ufw and firewalld: a container started with -p 8080:8080 is open to every network the computer is on, whatever ufw status says. Always give -p an address (127.0.0.1 or the LAN address), or filter in the DOCKER-USER chain:

sudo iptables -I DOCKER-USER -p tcp --dport 8080 ! -s 192.168.1.0/24 -j DROP

7. Where the data is, and backups

Everything the server keeps is in one data folder, in two SQLite databases:

FileWhat is in it
sliqtly.dbThe presentations, their versions and comments, and the server's settings.
blobs.dbThe files: pictures, Excel and CSV data, drawings.

Next to them are small working files (-wal and -shm files while the server runs). The folder is:

InstallData folderDaily backups
.deb/var/lib/sliqtly/var/lib/sliqtly-backup
Homebrew$(brew --prefix)/var/sliqtly$(brew --prefix)/var/sliqtly-backup
Docker/data (volume sliqtly-data)/backup (volume sliqtly-backup)

SLIQTLY_DATA and SLIQTLY_BACKUP move them. Do not copy the databases while the server runs: a copy taken mid-write can be broken. Either stop the service and copy the whole folder, or use the built-in backup, which is safe beside a running server.

The built-in backup

The server takes a backup at start when the last one is older than a day, then every day (SLIQTLY_BACKUP_EVERY, e.g. 12h), and keeps the last 3, 14 daily and 8 weekly ones (SLIQTLY_BACKUP_KEEP). Backups are incremental: an unchanged picture is stored once. An empty SLIQTLY_BACKUP turns them off. Mount another disk at the backup folder to keep it apart from the data.

# see and check the backups (.deb; Homebrew without sudo and with its folder)
sudo sliqtly-server backup list   -repo /var/lib/sliqtly-backup
sudo sliqtly-server backup verify -repo /var/lib/sliqtly-backup -deep

# a backup now, e.g. to a USB disk; safe while the server runs
sudo sliqtly-server backup run -data /var/lib/sliqtly -repo /media/usb/sliqtly-backup

# restore into a new folder (never over the live one); it is checked as it is written
sudo sliqtly-server backup restore -repo /var/lib/sliqtly-backup -id latest -into /var/lib/sliqtly-restored

# drop old backups by the same rule the server uses
sudo sliqtly-server backup prune -repo /var/lib/sliqtly-backup -keep last=3,daily=14,weekly=8

To look at a restored folder before using it, run a second server on it: sliqtly-server -data /var/lib/sliqtly-restored -port 8099. To switch to it, stop the service, move the old data folder aside, move the restored one into its place and start the service again.

In Docker the same commands run inside the container:

docker exec sliqtly /sliqtly-server backup list -repo /backup
docker exec sliqtly /sliqtly-server backup run -data /data -repo /backup

8. Update or remove

.deb

Download the newest package and install it the same way; the service restarts by itself.

sudo apt remove sliqtly-personal    # stops it; the presentations stay
sudo apt purge sliqtly-personal     # also removes /etc/sliqtly

Homebrew

brew upgrade sliqtly && brew services restart sliqtly
brew services stop sliqtly && brew uninstall sliqtly   # the presentations stay in $(brew --prefix)/var/sliqtly

Docker

docker pull ghcr.io/terotests/sliqtly-personal:latest
docker rm -f sliqtly                # then the same docker run as above
docker volume rm sliqtly-data sliqtly-backup   # only to delete the presentations too

Removing never deletes the presentations by itself; delete their folder or volume yourself if you want them gone.

9. Memory and load

We tested version 0.0.13 on Linux (amd64) for 15 minutes at a time, as the binary and in Docker with --memory=512m. Simulated AI agents and viewers worked in parallel: 4 for a minute, 16 for eight minutes, 64 for three minutes, then none for three minutes. The mix was what people and agents do: opening presentations in the viewer, reading and editing them, replacing Excel data (some of it damaged on purpose), drawing slide pictures, comments, and PDF and PowerPoint downloads. A backup ran every minute during the test.

At onceMemory, binaryMemory, Docker 512 MB
4about 140 MB (at most 150 MB)about 130 MB (at most 150 MB)
16about 310 MB (at most 350 MB)about 300 MB (at most 365 MB)
64about 500 MB (at most 630 MB)about 420 MB (at most 440 MB)
none, after the load145 MB135 MB

Memory is the server's resident memory (RSS), sampled every 5 seconds. In both runs, about 60,000 requests were handled with no crashes or internal errors, and memory went back down when the load stopped. Opening a presentation in the viewer took 0.2 s for half of the requests and under 0.8 s for 95% of them, even at 64 at once. 3,000 presentations were created, and the data folder grew to about 300 MB.

How much memory to give it. One person with an agent or two needs about 150 MB; 512 MB is enough for a team. In a container the server reads the memory limit and keeps itself below 80% of it, so it slows down instead of being stopped. With GOMEMLIMIT (e.g. -e GOMEMLIMIT=400MiB) you choose that limit yourself.

Refusals under load are intended. One address can make 2,000 changes in 10 minutes, and each caller can draw two slide pictures or downloads at a time. Beyond that the server answers "try again" (HTTP 429) instead of queueing work without end. An agent that edits the same slides as another at the same moment is told so, and nothing is overwritten. In the test, all of the refused requests were these.

The test also found problems, which were fixed before these numbers were measured: memory that was never released after requests, slow saves of large presentations (a 200-slide presentation went from 25 s to 0.4 s), slow handling of long HTML comments and Excel data, damaged ZIP and PNG files that could stop the server, PDF downloads from the viewer that did not work, and a container that the kernel stopped when it ran out of memory with 64 at once.

License

Free for personal use and qualifying solo businesses with annual gross revenue below €200,000. All other commercial use requires a commercial license. Read the license.