SlimAtlas AI

Funktionen

• Browser-Automatisierung: Navigieren, Klicken, Tippen, Ausfüllen von Formularen und Ausführen von JavaScript

• Standardmäßig ressourcenschonend: ~5x weniger Speicher als Chromium, ~25x kleinere Snapshots als rohes HTML

• Seiten-Snapshots: Kompakte YAML-Zugriffsbaum-Snapshots mit eindeutigen Knoten-IDs für präzises Targeting von Elementen

• LLM-optimierter Kontext: Snapshots werden auf das semantische Wesentliche reduziert, wodurch der Kontextverbrauch minimal bleibt und mehr Seiten und längere Sitzungen in dasselbe Fenster passen

• Konfigurierbarer Fallback-Browser: Zweistufiges Modell – zuerst der schlanke Browser, dann Eskalation auf Headful Chrome, Browserless oder Browserbase-Cloud-Browser nur, wenn der Standard erkannt wird, abstürzt oder eine Zeitüberschreitung auftritt

• Ratenbegrenzung: Unauffällig bleiben. Erzwingt eine konfigurierbare Mindestverzögerung zwischen Anfragen an bestimmte Domains mit Platzhaltermustern (*, *.reddit.com) plus optionalem Jitter, damit sich Ihr Agent selbst dosiert, anstatt eine Website zu überlasten und deren Bot-Abwehr auszulösen

• Proxy-Unterstützung: Leiten Sie jede Anfrage mit einer einzigen PROXY_SERVER-Einstellung durch einen HTTP-Proxy – automatisch auf beiden Browserebenen angewendet, sodass Ihre echte IP das Ziel nie erreicht. Unterstützt Inline-Basisauthentifizierung (http://user:pass@host:port)

• Robustes Sitzungsmanagement: Pro-Sitzungs-Serialisierung, optionale Sitzungsobergrenze (MAX_SESSIONS), Wiederherstellung nach Abstürzen mitten in der Sitzung mit Verlaufs-Wiederholung und kontrolliertes Herunterfahren

• Sitzungsverwaltung: Wiederverwendung von Sitzungen über mehrere Vorgänge mit eindeutigen Sitzungs-IDs

• Plattformübergreifend: Funktioniert unter Linux und macOS, bei Bedarf mit konfigurierbarem Fallback auf echte Browser

Related MCP server: opencode-browser-control

Benchmark

SlimAtlas wurde mit slim-atlas-bench gegen Playwright MCP (Headless- und Headful-Chromium) getestet – 25 reale Websites aus 5 Kategorien, 3 Durchläufe pro Website (insgesamt 225), alle in Docker auf localhost ausgeführt.

Aufbau: Jeder Dienst läuft als MCP-Server in einem eigenen Docker-Container. Die Benchmark-Umgebung misst die Latenz pro Tool-Aufruf (navigate + snapshot) über langchain-mcp-adapters und erfasst den Container-RAM über die Docker-Stats-API. Snapshots werden mit ~4 Zeichen/Token geschätzt (gleiche Methodik wie die rohe HTML-Baseline).

SlimAtlas tauscht Navigationsgeschwindigkeit gegen deutlich geringeren Ressourcenverbrauch. Chromium lädt Seiten schneller, verbraucht aber 5–6x mehr RAM und erzeugt 2–4x mehr Tokens pro Snapshot – die beiden Kostenfaktoren, die in Agent-Workflows im großen Maßstab dominieren.

Ergebnisse

Installation

Erfordert Bun ≥1.1.

# Install dependencies
bun install

Die Browser-Binärdatei wird beim ersten Start automatisch heruntergeladen.

Fallback-Browser: Stufe 1 ist immer der schlanke Browser. Stufe 2 ist FALLBACK_BROWSER – einer von headful (Headful Chrome), browserbase (Cloud), browserless (Cloud) oder none (Standard, kein Fallback). Wenn der Standard abstürzt, eine Zeitüberschreitung auftritt oder der Bot erkannt wird, wechselt die Sitzung einmalig zum konfigurierten Fallback. Chrome wird von Puppeteer mitgeliefert; Browserbase/Browserless erfordern API-Anmeldedaten (siehe unten).

Verwendung

MCP-Server ausführen

# Standalone HTTP server (default)
bun run src/index.ts --port=8080

# Remote, authenticated
MCP_AUTH_TOKEN=s3cret bun run src/index.ts --host=0.0.0.0 --port=8080

SlimAtlas stellt einen einzigen Streamable HTTP-Endpunkt /mcp bereit. Jeder Client erhält seine eigene Sitzung über den mcp-session-id-Header; MAX_SESSIONS begrenzt die Parallelität. Weisen Sie Ihren MCP-Client darauf hin:

{
  "mcpServers": {
    "slimatlas": {
      "url": "http://localhost:8080/mcp",
      "transport": "http"
    }
  }
}

Mit Authentifizierung:

{
  "mcpServers": {
    "slimatlas": {
      "url": "http://your-host:8080/mcp",
      "transport": "http",
      "headers": { "Authorization": "Bearer s3cret" }
    }
  }
}

Tipp: Verwenden Sie --host=0.0.0.0 für den Fernzugriff, aber setzen Sie dabei immer MCP_AUTH_TOKEN. Der Server spricht nur einfaches HTTP – beenden Sie TLS davor (Caddy/nginx) oder das Bearer-Token wird im Klartext über das Netzwerk gesendet.

Docker

Das Image bündelt die Lightpanda-Binärdatei bereits beim Build, sodass der Container eigenständig startet und nie erneut herunterlädt:

docker build -t slimatlas .
docker run -p 8080:8080 -e MCP_AUTH_TOKEN=s3cret slimatlas
# -> http://localhost:8080/mcp

Pinnen Sie eine Lightpanda-Version für reproduzierbare Builds (beliebiges lightpanda-io/browser-Tag – Standard nightly):

docker build --build-arg LIGHTPANDA_VERSION=0.3.3 -t slimatlas:0.3.3 .

Multi-Arch wird automatisch gehandhabt – der Build erkennt die Architektur des Containers über uname -m (x86_64 → lightpanda-x86_64-linux, aarch64 → lightpanda-aarch64-linux), sodass die Binärdatei immer zur Plattform passt, für die gebaut wird.

Apple Silicon (M-Serie-Macs): Übergeben Sie --platform linux/arm64, um nativ zu bauen/auszuführen. Andernfalls verwendet Docker Desktop möglicherweise standardmäßig amd64 und führt den Container unter Rosetta aus, was beim Start der Lightpanda-Binärdatei fehlschlägt (rosetta error: failed to open elf …).

docker build --platform linux/arm64 --build-arg FALLBACK_BROWSER=headful -t slimatlas .
docker run --platform linux/arm64 --name slimatlas -p 8080:8080 -e MCP_AUTH_TOKEN=s3cret -e LIGHTPANDA_POOL_SIZE=10 -e CHROME_POOL_SIZE=10 slimatlas

Headful-Fallback-Variante. Das Standard-Image führt nur Lightpanda aus (FALLBACK_BROWSER=none). Um den Headful-Chrome-Fallback zu aktivieren (nur erforderlich, wenn Sie FALLBACK_BROWSER=headful zur Laufzeit setzen), bauen Sie die Headful-Variante – sie fügt die Chrome-Laufzeitbibliotheken + Xvfb (~150 MB) hinzu und setzt FALLBACK_BROWSER=headful vorab:

docker build --build-arg LIGHTPANDA_VERSION=0.3.3 FALLBACK_BROWSER=headful -t slimatlas:headful .
docker run -p 8080:8080 -e MCP_AUTH_TOKEN=s3cret slimatlas:headful

Xvfb wird lazy im Container bei der ersten Sitzung gestartet, die auf Headful Chrome eskaliert – kein Entrypoint oder manuelles xvfb-run erforderlich.

Stdio-Modus

Für MCP-Clients, die den Server als Unterprozess starten (lokal, einzelner Client), verwenden Sie den Stdio-Transport:

bun run src/index.ts

{
  "mcpServers": {
    "slimatlas": {
      "command": "bun",
      "args": ["run", "path/to/mcp/src/index.ts"]
    }
  }
}

Konfiguration

Fügen Sie Folgendes zu Ihrer MCP-Client-Konfiguration hinzu:

{
  "mcpServers": {
    "slimatlas": {
      "command": "bun",
      "args": ["run", "path/to/mcp/src/index.ts"]
    }
  }
}

Tipp: Setzen Sie FALLBACK_BROWSER=none, um nur den schlanken Browser zu verwenden und Fehler ehrlich weiterzugeben. Verwenden Sie headful oder browserbase, um einen Fallback auf echte Browser zu aktivieren.

Alle Umgebungsvariablen und CLI-Flags finden Sie in docs/configs.md.

Fallback-Browser

Überspringen Sie den Standardbrowser für bekannte schwierige Domains mit SKIP_LIGHTPANDA_DOMAINS (durch Kommas getrennt, subdomain-bewusst). Übereinstimmende Hosts starten direkt im Fallback-Browser. Erfordert FALLBACK_BROWSER != none (andernfalls wird die Liste mit einer Warnung ignoriert).

Ratenbegrenzung

Höfliches, Anti-Erkennungs-Timing für Ihren Agenten. RateLimiter erzwingt eine serverweite Mindestverzögerung zwischen browser_navigate-Aufrufen an die von Ihnen aufgelisteten Domains, mit optionalem zufälligem Jitter, damit das Tempo kein festes, identifizierbares Intervall ist. Buckets werden pro Host über alle Sitzungen hinweg vergeben (da die Zielwebsite Ihre IP sieht, nicht Ihre Sitzungen), und Muster unterstützen Platzhalter:

Standardmäßig deaktiviert. Aktivieren Sie mit einer nicht leeren Domain-Liste und einer Verzögerung ungleich Null:

# Via CLI flags
bun run src/index.ts --rate-limit-domains=*.reddit.com,g2.com --rate-limit-min-delay-ms=2000 --rate-limit-jitter-ms=1500

# Or via environment / .env
RATE_LIMIT_DOMAINS=*.reddit.com,g2.com
RATE_LIMIT_MIN_DELAY_MS=2000
RATE_LIMIT_JITTER_MS=1500

Proxy

Halten Sie Ihre echte IP vom Ziel fern. Setzen Sie einen einzigen PROXY_SERVER und SlimAtlas leitet den gesamten HTTP-Datenverkehr beider Browserebenen darüber – keine pro-Browser-Verkabelung erforderlich:

• Schlanker Browser (Stufe 1) – über das native --http-proxy-Flag weitergeleitet.

• Chrome-Fallback (Stufe 2) – über --proxy-server beim Start angewendet.

# Via CLI flag
bun run src/index.ts --proxy-server=http://host:8080

# Or via environment / .env
PROXY_SERVER=http://user:pass@host:8080

Inline-Basisauthentifizierung (http://user:pass@host:port) wird auf der schlanken Browserebene unterstützt. Für Proxys mit IP-Freischaltung (ohne Anmeldedaten) funktioniert es auf beiden Ebenen sofort. (Pro-Seiten-Chrome-Authentifizierung über page.authenticate ist auf der Roadmap.)

CLI-Flags

Jede Umgebungsvariable kann auch als Kleinbuchstaben-CLI-Flag im Format --flag=value übergeben werden. CLI-Flags überschreiben Umgebungsvariablen. Unbekannte Flags führen dazu, dass der Server beim Start beendet wird. Die vollständige Liste finden Sie in docs/configs.md.

bun run src/index.ts --fallback-browser=headful --lightpanda-pool-size=3 --skip-lightpanda-domains=g2.com --navigate-timeout=60000

Um Flags von einem MCP-Client aus zu verwenden, hängen Sie sie an das args-Array an:

{
  "mcpServers": {
    "slimatlas": {
      "command": "bun",
      "args": [
        "run",
        "path/to/mcp/src/index.ts",
        "--fallback-browser=headful",
        "--skip-lightpanda-domains=g2.com,linkedin.com",
        "--chrome-pool-size=3"
      ]
    }
  }
}

Arbeitsablauf

# Example: Navigate, snapshot, and interact with a page

# 1. Navigate to a URL (creates a new session automatically)
result = mcp.call("browser_navigate", {"url": "https://example.com"})
# Returns: session_id: abc1, result: Navigated to https://example.com. Title: Example Domain

# 2. Take a snapshot to see the page structure
snapshot = mcp.call("browser_snapshot", {"session_id": "abc1"})
# Returns YAML with node IDs like: 0: {type: div, children: ...}

# 3. Click a node by ID (from the snapshot)
mcp.call("browser_click", {"session_id": "abc1", "nodeId": 2})

# 4. Type into a search box
mcp.call("browser_type", {"session_id": "abc1", "nodeId": 5, "text": "search query"})

# 5. Close the session when done
mcp.call("browser_close", {"session_id": "abc1"})

Verfügbare Tools

Tests ausführen

# Run all tests
bun test

# Run tests in watch mode
bun test --watch

Anforderungen

• Bun ≥1.1

• Linux oder macOS (lädt automatisch herunter) oder Chrome/Chromium (Fallback)

Lizenz

MIT