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
- Data stays between your machine and your agent. Presentations, pictures and data files are kept on your own disk, not in a cloud service.
- Private, if you keep it to yourself. Out of the box only this computer can connect, so nothing is reachable by a link from outside.
- Nothing expires. Presentations and their files stay until you delete them. (The cloud demo removes anonymous presentations some days after their last change.)
- No sign-in, no quotas. Every connected agent can read, change and remove every presentation, from any conversation; a new conversation keeps working on old presentations by their links.
- Works offline once installed, apart from pictures your agent asks it to fetch from the web.
Responsibilities for local users
- Your data. The server is an open store for everything you make: what goes in it, and who may see it, is up to you.
- Cleaning up. Nothing is removed for you. Ask your agent to tidy up, or delete a presentation with
curl -X DELETE http://localhost:8080/api/shares/<id>. - Backups. The server takes daily backups, but keeping them on another disk, checking them and restoring is yours; see Where the data is, and backups.
- Access. Anyone who can reach the server can do everything an agent can. Keep it to this computer unless you trust everyone on the network; see Networks and Firewall.
- Infrastructure. The computer or server it runs on, its operating system and updates, disks, network, firewall and any proxy in front of it, and updating Sliqtly itself.
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:
| Install | Change | Then |
|---|---|---|
| .deb | PORT=8090 in /etc/sliqtly/sliqtly.env | sudo systemctl restart sliqtly |
| Homebrew | PORT=8090 in $(brew --prefix)/etc/sliqtly/sliqtly.env | brew services restart sliqtly |
| Docker | the left side of -p: -p 127.0.0.1:8090:8080 | remove 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.
| Setting | Default | What it does |
|---|---|---|
PORT | 8080 | The port the server listens on. |
SLIQTLY_LISTEN | local | Who can connect: local, wired or network; see Networks. Docker sets network inside the container and leaves the choice to -p. |
SLIQTLY_ALLOW | empty | With wired or network: only these address ranges, e.g. 192.168.1.0/24. This computer is always let in. |
SLIQTLY_TOKEN | empty | When 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_URL | the address a request came in on | The address in the links the server gives, e.g. http://my-pc.local:8080 or https://slides.example.com. |
SLIQTLY_DATA | .deb /var/lib/sliqtlyHomebrew $(brew --prefix)/var/sliqtlyDocker /data | Where the presentations are kept. |
SLIQTLY_BACKUP | the same with -backup (Docker /backup) | A daily backup of the presentations; empty turns it off. |
SLIQTLY_IMPORT_DIRS | empty | Folders your agent may take pictures and data files from by path; see Pictures from a folder. |
SLIQTLY_MAX_FILE_MB | 50 | The 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.
- Anyone who can use this server's
/mcpcan read the pictures and data files in these folders. Name only folders meant for presentations, and keepSLIQTLY_LISTEN=localor setSLIQTLY_TOKEN. - Ubuntu and Debian: the service runs as a user of its own with
/homehidden. Use a folder outside/homethat everyone can read, or allow home folders withsudo systemctl edit sliqtlyand[Service]ProtectHome=read-only. - macOS: the service runs as you. Folders macOS protects (Desktop, Documents, Downloads, Pictures) may need Full Disk Access for
sliqtly-server; a folder of your own elsewhere in your home folder needs nothing. - Docker: mount the folder and name the path inside the container, e.g.
-v /Users/me/photoalbum:/import:ro -e SLIQTLY_IMPORT_DIRS=/import. The agent then gives paths such as/import/trip/cover.jpg.
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 Homebrew | Docker |
|---|---|---|
| Only this computer | SLIQTLY_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 internet | Do 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.
- Agents add the header
Authorization: Bearer a-long-random-secret(Claude Code:--header "Authorization: Bearer …"), and use this computer's name or address instead oflocalhost, e.g.http://my-pc.local:8080/mcp. - Browsers open the server once with the token in the address,
http://my-pc.local:8080/?token=a-long-random-secret, or type it into the page that asks for it. The browser then keeps a cookie for this server only, which no other website can use.
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:
| File | What is in it |
|---|---|
sliqtly.db | The presentations, their versions and comments, and the server's settings. |
blobs.db | The 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:
| Install | Data folder | Daily 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 once | Memory, binary | Memory, Docker 512 MB |
|---|---|---|
| 4 | about 140 MB (at most 150 MB) | about 130 MB (at most 150 MB) |
| 16 | about 310 MB (at most 350 MB) | about 300 MB (at most 365 MB) |
| 64 | about 500 MB (at most 630 MB) | about 420 MB (at most 440 MB) |
| none, after the load | 145 MB | 135 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.