Charlotte
Charlotte
Das Web, lesbar.
Dein KI-Agent verbrennt ~50.000 Zeichen Accessibility-Baum, nur um die Hacker-News-Startseite anzusehen. Charlotte schafft das in 364.
Charlotte ist ein MCP-Server, der KI-Agenten einen strukturierten, token-effizienten Zugriff auf das Web bietet. Statt bei jedem Aufruf den gesamten Accessibility-Baum auszugeben, liefert Charlotte nur das zurück, was der Agent braucht: eine kompakte Seitenzusammenfassung beim Eintreffen, gezielte Abfragen für bestimmte Elemente und volle Details nur auf ausdrückliche Anfrage. Auf inhaltsreichen Seiten ist diese Orientierung bis zu ~140x kleiner als ein vollständiger Accessibility-Baum-Schnappschuss von Playwright MCP; auf trivial kleinen Seiten sind beide ungefähr gleich groß.
Warum Charlotte?
Die meisten Browser-MCP-Server geben bei jedem Aufruf den gesamten Accessibility-Baum aus – ein flacher Textblock, der auf inhaltsreichen Seiten über eine Million Zeichen überschreiten kann. Agenten zahlen dafür, ob sie es brauchen oder nicht.
Charlotte zerlegt jede Seite in eine typisierte, strukturierte Darstellung – Landmarks, Überschriften, interaktive Elemente, Formulare, Inhaltszusammenfassungen – und lässt Agenten steuern, wie viel sie erhalten, mit drei Detailstufen. Wenn ein Agent zu einer neuen Seite navigiert, erhält er eine kompakte Orientierung (364 Zeichen für Hacker News) statt des vollständigen Element-Dumps (~50.000 Zeichen). Wenn er Details braucht, fragt er danach.
Benchmarks
Gemessen mit Charlotte v0.8.0 gegen Playwright MCP v0.0.79, nach Zeichen pro Tool-Aufruf auf echten Websites (npx tsx benchmarks/run-benchmarks.ts --suite comparison), 2026-08-08. Dieser Abschnitt ist eine Zusammenfassung – die kanonische Benchmarks-Seite (einschließlich Kosten pro Aufgabe und Release-Drift) ist charlotte.mintlify.site/benchmarks; Methodik, Instrumente und Rohdaten: benchmarks/.
Orientierungskosten (was ein Agent zahlt, um eine Seite beim Eintreffen zu „sehen“):
Ein Charlotte-navigate liefert standardmäßig eine nutzbare Orientierung – Landmarks, Überschriften und Anzahl interaktiver Elemente, gruppiert nach Seitenregion. Um das Äquivalent mit Playwright MCP zu erhalten, ruft ein Agent browser_snapshot auf, das den vollständigen Accessibility-Baum zurückgibt. (Playwrights browser_navigate allein liefert nur eine kurze Bestätigung, nicht den Seiteninhalt, daher ist es kein direkter Vergleich.)
Site | Charlotte | Playwright | Kleiner um |
example.com | 415 | 465 | 1.1x |
httpbin-Formular | 619 | 1,847 | 3.0x |
GitHub-Repository | 3,778 | 38,983 | 10x |
Wikipedia (KI-Artikel) | 22,134 | 1,137,928 | 51x |
Hacker News | 364 | 50,706 | 139x |
Der Vorteil skaliert mit der Seitenkomplexität: Auf inhaltsreichen Seiten ist die strukturierte Orientierung ~10–140x kleiner als der vollständige Schnappschuss, während auf einer trivial kleinen Seite wie example.com beide innerhalb von ~20% liegen (und auf einer so kleinen Seite kann die strukturierte Darstellung die größere der beiden sein – es gibt schlicht nichts zusammenzufassen). Charlottes Wert zeigt sich genau dort, wo Playwrights flacher Dump am meisten schmerzt. Wenn ein Agent mehr als die Orientierung benötigt, ruft er observe oder find für genau den Teil auf, den er möchte, statt den gesamten Baum im Voraus zu bezahlen.
Overhead der Tool-Definitionen (unsichtbare Kosten pro API-Aufruf):
Profil | Tools | Def. Tokens/Aufruf | Ersparnis vs. voll |
voll | 43 | 8.500 | — |
browse (Standard) | 23 | 4.372 | ~49% |
core | 7 | 2.186 | ~75% |
Tool-Definitionen werden bei jedem API-Round-Trip gesendet. Mit dem Standardprofil browse trägt Charlotte ~49% weniger Definitions-Overhead als beim Laden aller 43 Tools; das minimale core-Profil reduziert ihn um ~75%. Siehe den Profil-Benchmark-Bericht für vollständige Ergebnisse.
Der Workflow-Unterschied: Ein Playwright-Agent, der den vollständigen Schnappschuss liest, erhält ~50.000 Zeichen jedes Mal, wenn er Hacker News ansieht, egal ob er Schlagzeilen liest oder nach einem Login-Button sucht. Ein Charlotte-Agent erhält 364 Zeichen beim Eintreffen, ruft find({ type: "link", text: "login" }) auf, um genau das zu bekommen, was er braucht, und zahlt nie für den Rest.
Related MCP server: stealth-agent-browser-mcp
So funktioniert es
Charlotte unterhält eine persistente Headless-Chromium-Sitzung und fungiert als Übersetzungsschicht zwischen dem visuellen Web und dem textbasierten Denken des Agenten. Jede Seite wird in eine strukturierte Darstellung zerlegt:
┌─────────────┐ MCP Protocol ┌──────────────────┐
│ AI Agent │<────────────────────>│ Charlotte │
└─────────────┘ │ │
│ ┌────────────┐ │
│ │ Renderer │ │
│ │ Pipeline │ │
│ └─────┬──────┘ │
│ │ │
│ ┌─────▼──────┐ │
│ │ Headless │ │
│ │ Chromium │ │
│ └────────────┘ │
└──────────────────┘Agenten erhalten Landmarks, Überschriften, interaktive Elemente mit typisierten Metadaten, Begrenzungsrahmen, Formularstrukturen und Inhaltszusammenfassungen – alles abgeleitet aus dem, was der Browser bereits über jede Seite weiß.
Funktionen
Navigation — navigate, back, forward, reload
Beobachtung — observe (3 Detailstufen, strukturelle Baumansicht), find (räumliche + semantische Suche, CSS-Selektor-Modus, output_file für große Ergebnismengen), screenshot (mit persistentem Artefakt-Management), screenshots, screenshot_get, screenshot_delete, diff (struktureller Vergleich mit Schnappschüssen)
Interaktion (iframe-bewusst) — click, click_at (koordinatenbasiert), type (mit langsamer Eingabeunterstützung), select, toggle, submit, scroll, hover, drag, key (einzeln/sequenziell mit Element-Ziel), wait_for (asynchrones Bedingungs-Polling), upload (Dateieingabe), fill_form (Stapel-Formularausfüllung), dialog (JS-Dialoge akzeptieren/ablehnen)
Überwachung — console (alle Schweregrade, Filterung, Zeitstempel), requests (vollständiger HTTP-Verlauf, Filterung nach Methode/Status/Ressourcentyp)
Sitzungsverwaltung — tabs, tab_open, tab_switch, tab_close, viewport (generische Voreinstellungen oder benannte Geräte wie „iPhone 15“ mit DPR-, Touch- und User-Agent-Emulation), network (Drosselung, URL-Blockierung), set_cookies, get_cookies, clear_cookies, set_headers, configure
Entwicklungsmodus — dev_serve (statischer Server + Dateiüberwachung mit automatischem Neuladen), dev_inject (CSS/JS-Injektion), dev_audit (a11y, Leistung, SEO, Kontrast, defekte Links)
Dienstprogramme — evaluate (beliebige JS-Ausführung im Seitenkontext)
Tool-Profile
Charlotte bringt 43 Tools mit (42 registrierte + das Meta-Tool charlotte_tools), aber die meisten Workflows benötigen nur eine Teilmenge. Startprofile steuern, welche Tools in den Kontext des Agenten geladen werden, und reduzieren den Definitions-Overhead um bis zu ~75%.
charlotte --profile browse # 23 tools (default) — navigate, observe, interact, tabs
charlotte --profile core # 7 tools — navigate, observe, find, click, type, submit
charlotte --profile full # 43 tools — everything
charlotte --profile interact # 31 tools — full interaction + dialog + evaluate
charlotte --profile develop # 34 tools — interact + dev_serve, dev_inject, dev_audit
charlotte --profile audit # 14 tools — navigation + observation + dev_audit + viewportAgenten können während der Sitzung weitere Tools aktivieren, ohne neu zu starten:
charlotte_tools enable dev_mode → activates dev_serve, dev_audit, dev_inject
charlotte_tools disable dev_mode → deactivates them
charlotte_tools list → see what's loadedSelbst-Hosting (Charlotte Remote)
Führe Charlotte als Remote-MCP-Server aus und verbinde ihn mit claude.ai – ein Befehl:
docker run --cap-add SYS_ADMIN --shm-size 2g -p 3737:3737 ghcr.io/ticktockbent/charlotteEr gibt eine öffentliche Connector-URL und ein Operator-Token aus. In claude.ai: Einstellungen → Connectors → Benutzerdefinierten Connector hinzufügen – füge die URL ein, lasse die OAuth-Client-ID/Secret-Felder leer und gib das Token auf Charlottes Zustimmungsseite ein, wenn sie erscheint. Das war's; du surfst.
Die Demo-URL und das Token sind ephemer (beide rotieren beim Neustart). Für den echten Betrieb – stabile Domain, eigener Tunnel oder Reverse-Proxy, Docker Compose: Selbst-Hosting. Vertrauensmodell und Netzwerk-Schutz: Sicherheit. Container- und Sandbox-Interna: Docker.
Schnellstart
Voraussetzungen
Node.js >= 20
npm
Installation
Charlotte ist im MCP-Registry als io.github.TickTockBent/charlotte gelistet und auf npm als @ticktockbent/charlotte veröffentlicht:
npm install -g @ticktockbent/charlotteDocker-Images sind auf Docker Hub und GitHub Container Registry verfügbar:
# Alpine (default, smaller)
docker pull ticktockbent/charlotte:alpine
# Debian (if you need glibc compatibility)
docker pull ticktockbent/charlotte:debian
# Or from GHCR
docker pull ghcr.io/ticktockbent/charlotte:latestOder aus dem Quellcode installieren:
git clone https://github.com/ticktockbent/charlotte.git
cd charlotte
npm install
npm run buildAusführen
Charlotte kommuniziert über stdio mit dem MCP-Protokoll:
# If installed globally (default browse profile)
charlotte
# With a specific profile
charlotte --profile core
# If installed from source
npm startMCP-Client-Konfiguration
Claude Code
Erstelle .mcp.json im Projektstamm:
{
"mcpServers": {
"charlotte": {
"type": "stdio",
"command": "npx",
"args": ["@ticktockbent/charlotte"],
"env": {}
}
}
}Claude Desktop
Füge zu claude_desktop_config.json hinzu:
{
"mcpServers": {
"charlotte": {
"command": "npx",
"args": ["@ticktockbent/charlotte"]
}
}
}Cursor
Füge zu .cursor/mcp.json hinzu:
{
"mcpServers": {
"charlotte": {
"command": "npx",
"args": ["@ticktockbent/charlotte"]
}
}
}Windsurf
Füge zu ~/.codeium/windsurf/mcp_config.json hinzu:
{
"mcpServers": {
"charlotte": {
"command": "npx",
"args": ["@ticktockbent/charlotte"]
}
}
}VS Code (Copilot)
Füge zu .vscode/mcp.json hinzu:
{
"servers": {
"charlotte": {
"type": "stdio",
"command": "npx",
"args": ["@ticktockbent/charlotte"]
}
}
}Cline
Füge zu den Cline-MCP-Einstellungen hinzu (über die Cline-Seitenleiste > MCP-Server > Konfigurieren):
{
"mcpServers": {
"charlotte": {
"command": "npx",
"args": ["@ticktockbent/charlotte"]
}
}
}Amp
Füge zu ~/.amp/settings.json hinzu:
{
"mcpServers": {
"charlotte": {
"command": "npx",
"args": ["@ticktockbent/charlotte"]
}
}
}Siehe docs-internal/mcp-setup.md für die vollständige Einrichtungsanleitung, einschließlich Entwicklungsmodus, generischer MCP-Clients, Verifizierungsschritte und Fehlerbehebung.
Konfiguration
Charlotte löst Einstellungen aus vier Quellen auf, mit höchster Priorität zuerst: CLI-Argumente → Umgebungsvariablen → Konfigurationsdatei → eingebaute Standardwerte. Siehe docs/configuration.md für die vollständige Referenz.
Konfigurationsdatei
Übergib eine JSON-Konfigurationsdatei mit --config oder lege eine charlotte.config.json im Arbeitsverzeichnis ab, und Charlotte lädt sie automatisch:
charlotte --config charlotte.config.json{
"browser": { "headless": true, "noSandbox": false },
"tools": { "profile": "browse" },
"rendering": { "includeIframes": false, "iframeDepth": 3 },
"output": { "dir": "./charlotte-output" },
"limits": {
"maxInteractiveElements": 2000,
"maxFullContentChars": 200000,
"maxResponseBytes": 1000000,
"maxEvaluateBytes": 256000
}
}Jeder Abschnitt ist optional; ein leeres {} ist gültig. Die Datei wird mit zod validiert – unbekannte Schlüssel, falsche Typen oder ungültige Enum-Werte erzeugen eine klare Startfehlermeldung auf stderr, und Charlotte beendet sich mit einem Nicht-Null-Exit-Code. Vier Einstellungen haben auch Umgebungsvariablen: CHARLOTTE_NO_SANDBOX, CHARLOTTE_OUTPUT_DIR, CHARLOTTE_CDP_ENDPOINT und CHARLOTTE_INIT_SCRIPT. Skripte, die bei jedem neuen Dokument vor dem Seiten-JS ausgeführt werden sollen, kommen in browser.initScripts oder --init-script <Pfad> (wiederholbar); siehe Init-Skripte.
Die Chromium-Sandbox ist standardmäßig aktiviert
Verhaltensänderung in v0.7.0: Frühere Versionen haben
--no-sandboxin jeden Chromium-Start eingebaut. Seit v0.7.0 ist die Chromium-Sandbox standardmäßig aktiviert – die primäre Verteidigung zwischen einer nicht vertrauenswürdigen Seite und dem Konto, unter dem Charlotte läuft. Du musst explizit abwählen, wo die Kernel-Sandbox nicht verfügbar ist.
charlotte --no-sandbox # CLI flag
CHARLOTTE_NO_SANDBOX=1 charlotte # environment variable
# or "browser": { "noSandbox": true } in the config fileMigrationshinweis (Docker / Bare-Metal): Container können die Kernel-Sandbox normalerweise nicht einrichten, daher setzen die bereitgestellten Dockerfiles CHARLOTTE_NO_SANDBOX=1 für dich, und docker-compose.yml behält jetzt den Standard-seccomp-Filter von Docker bei (es läuft nicht mehr mit seccomp=unconfined). Wenn du Charlotte bare-metal als root ausführst, weigert sich Chromium, mit aktivierter Sandbox zu starten – führe es als Nicht-Root-Benutzer aus (empfohlen) oder übergib --no-sandbox. Bestehende Setups, die zuvor auf das implizite --no-sandbox angewiesen waren und in einer Umgebung laufen, in der die Sandbox nicht initialisiert werden kann, müssen jetzt CHARLOTTE_NO_SANDBOX=1 (oder das Flag/Konfigurationsäquivalent) setzen, um weiter zu funktionieren.
Das Ausführen von Charlotte Remote (HTTP-Modus) über das Netzwerk wirft zusätzliche Fragen zu Vertrauensgrenzen und Netzwerk-Schutz auf, die über die Sandbox hinausgehen – siehe Sicherheit.
Ausgabegrößen-Limits
Die limits.*-Schlüssel begrenzen, wie viel eine einzelne Tool-Antwort zurückgeben kann, damit eine pathologische Seite (100k Links, ein Endlos-Scroll-Feed, ein riesiger Dokumentkörper) den Kontextfenster des Agenten nicht überlaufen lässt. Wenn eine Seitenantwort maxResponseBytes überschreitet, wird sie zu einer kompakten Zusammenfassung degradiert und schlägt vor, das vollständige Ergebnis über output_file auf die Festplatte zu schreiben; charlotte_evaluate-Ergebnisse werden unabhängig durch maxEvaluateBytes begrenzt. Abgeschnittene Antworten tragen einen truncation-Marker. Siehe docs/configuration.md für die Schlüssel und Standardwerte.
Absturz-Wiederherstellung
Ein Chromium-Absturz blockiert den Server nicht mehr. Der nächste Tool-Aufruf startet den Browser automatisch neu, leert die Caches für tote Tabs und CDP-Sitzungen und öffnet einen neuen leeren Tab – so kann ein Agent nach einem Renderer-Absturz weiterarbeiten, ohne den MCP-Server neu zu starten.
Verwendungsbeispiele
Sobald die Verbindung steht, kann ein Agent Charlottes Tools verwenden:
Eine Website durchsuchen
navigate({ url: "https://example.com" })
// → 612 chars: landmarks, headings, interactive element counts
find({ type: "link", text: "More information" })
// → just the matching element with its ID
click({ element_id: "lnk-a3f1c2" })Ein Formular ausfüllen
navigate({ url: "https://httpbin.org/forms/post" })
find({ type: "text_input" })
type({ element_id: "inp-c7e29b", text: "hello@example.com" })
select({ element_id: "sel-e8a3f5", value: "option-2" })
submit({ form_id: "frm-b1d4e7" })Lokale Entwicklungs-Feedbackschleife
dev_serve({ path: "./my-site", watch: true })
observe({ detail: "full" })
dev_audit({ checks: ["a11y", "contrast"] })
dev_inject({ css: "body { font-size: 18px; }" })Seitenrepräsentation
Charlotte liefert strukturierte Repräsentationen mit drei Detailstufen, die es Agenten ermöglichen, zu steuern, wie viel Kontext sie verbrauchen:
Minimal (Standard für navigate)
Landmarks, Überschriften und Zählungen interaktiver Elemente, gruppiert nach Seitenregion. Entwickelt für die Orientierung – „Was ist auf dieser Seite?" – ohne jedes Element aufzulisten.
{
"url": "https://news.ycombinator.com",
"title": "Hacker News",
"viewport": { "width": 1280, "height": 720 },
"structure": {
"headings": [{ "level": 1, "text": "Hacker News", "id": "hdg-a1b2c3" }]
},
"interactive_summary": {
"total": 93,
"by_landmark": {
"(page root)": { "link": 91, "text_input": 1, "button": 1 }
}
}
}Summary (Standard für observe)
Vollständige Liste interaktiver Elemente mit typisierten Metadaten, Formularstrukturen und Inhaltszusammenfassungen.
{
"url": "https://example.com/dashboard",
"title": "Dashboard",
"viewport": { "width": 1280, "height": 720 },
"structure": {
"landmarks": [
{ "id": "rgn-b2c1d0", "role": "banner", "label": "Site header", "bounds": { "x": 0, "y": 0, "w": 1280, "h": 64 } },
{ "id": "rgn-d4e5f6", "role": "main", "label": "Content", "bounds": { "x": 240, "y": 64, "w": 1040, "h": 656 } }
],
"headings": [{ "level": 1, "text": "Dashboard", "id": "hdg-1a2b3c" }],
"content_summary": "main: 2 headings, 5 links, 1 form"
},
"interactive": [
{
"id": "btn-a3f1c2",
"type": "button",
"label": "Create Project",
"bounds": { "x": 960, "y": 80, "w": 160, "h": 40 },
"state": {}
}
],
"forms": []
}Full
Alles aus summary, plus den gesamten sichtbaren Textinhalt der Seite.
Detailstufen
Level | Tokens | Verwendungszweck |
| ~50-200 | Orientierung nach der Navigation. Welche Regionen gibt es? Wie viele interaktive Elemente? |
| ~500-5000 | Arbeiten mit der Seite. Vollständige Elementliste, Formularstrukturen, Inhaltszusammenfassungen. |
| variabel | Lesen des Seiteninhalts. Der gesamte sichtbare Text ist enthalten. |
Navigationstools verwenden standardmäßig minimal. Das observe-Tool verwendet standardmäßig summary. Beide akzeptieren einen optionalen detail-Parameter zum Überschreiben.
Element-IDs
Element-IDs sind über kleinere DOM-Mutationen hinweg stabil. Sie werden durch Hashing eines zusammengesetzten Schlüssels aus Elementtyp, ARIA-Rolle, zugänglichem Namen und DOM-Pfadsignatur erzeugt:
btn-a3f1c2 (button) inp-c7e29b (text input)
lnk-d4b910 (link) sel-e8a3f5 (select)
chk-f1a204 (checkbox) frm-b1d4e7 (form)
rgn-e0d2a8 (landmark) hdg-0f4063 (heading)
dom-b2c3d9 (DOM element, from CSS selector queries)v0.7.0-ID-Formatänderung: Element-ID-Hashes sind jetzt 6 Hexadezimalzeichen (z. B.
btn-a3f1c2), gegenüber 4 in früheren Versionen. Dies reduziert Hash-Kollisionen zwischen Elementen auf großen Seiten drastisch. Agenten, die 4-stellige IDs fest codiert oder per Muster abgeglichen haben, sollten Elemente nach dem Upgrade erneut perfindsuchen, anstatt zwischengespeicherte IDs wiederzuverwenden.
IDs überstehen unabhängige DOM-Änderungen und Neuanordnungen von Elementen innerhalb desselben Containers. Wenn ein Agent mit minimaler Detailstufe navigiert (ohne einzelne Element-IDs), verwendet er find, um Elemente anhand von Text, Typ oder räumlicher Nähe zu lokalisieren – die zurückgegebenen Elemente enthalten IDs, die für die Interaktion bereit sind.
Entwicklung
# Run in watch mode
npm run dev
# Run all tests
npm test
# Run only unit tests
npm run test:unit
# Run only integration tests
npm run test:integration
# Type check
npx tsc --noEmitProjektstruktur
src/
browser/ # Puppeteer lifecycle, tab management, CDP sessions
renderer/ # Accessibility tree extraction, layout, content, element IDs
state/ # Snapshot store, structural differ
tools/ # MCP tool definitions (navigation, observation, interaction, session, dev-mode)
dev/ # Static server, file watcher, auditor
types/ # TypeScript interfaces
utils/ # Logger, hash, wait utilities
tests/
unit/ # Fast tests with mocks
integration/ # Full Puppeteer tests against fixture HTML
fixtures/pages/ # Test HTML filesArchitektur
Die Renderer-Pipeline ist der Kern – sie ruft Extraktoren in Reihenfolge auf und setzt eine PageRepresentation zusammen:
Extraktion des Accessibility-Baums (CDP
Accessibility.getFullAXTree)Layout-Extraktion (CDP
DOM.getBoxModel)Extraktion von Landmarks, Überschriften, interaktiven Elementen und Inhalten
Generierung von Element-IDs (hashbasiert, stabil über Neu-Renderings hinweg)
Alle Tools laufen über renderActivePage(), das Snapshots, Reload-Ereignisse, Dialogerkennung und Antwortformatierung übernimmt.
Sandbox
Charlotte enthält eine Testwebsite in tests/sandbox/, die alle Tools ohne Zugriff auf das öffentliche Internet testet. Lokal bereitstellen mit:
dev_serve({ path: "tests/sandbox" })Fünf Seiten decken Navigation, Formulare, interaktive Elemente, Popups, verzögerten Inhalt, Scroll-Container und mehr ab. Siehe docs-internal/sandbox.md für die vollständige Seitenreferenz und eine toolweise Übungscheckliste.
Bekannte Probleme
Shadow DOM – Offenes Shadow DOM funktioniert transparent. Der Accessibility-Baum von Chromium durchdringt offene Shadow-Grenzen, sodass Webkomponenten (z. B. GitHub's <relative-time>, <tool-tip>) ihren Inhalt ohne spezielle Behandlung in Charlottes Repräsentation rendern. Geschlossene Shadow-Roots sind für den Accessibility-Baum undurchsichtig und werden nicht erfasst.
Roadmap
Sitzung & Konfiguration
Feature-Roadmap
Videoaufzeichnung – Interaktionen als Video aufzeichnen, um die vollständige Sequenz agentengesteuerter Navigation und Manipulation für Debugging, Dokumentation und Überprüfung zu erfassen.
Siehe docs-internal/playwright-mcp-gap-analysis.md für die vollständige Gap-Analyse gegenüber Playwright MCP, einschließlich Prioritäten mit niedrigerer Priorität (Vision-Tools, Testen/Verifizieren, Tracing, Transport, Sicherheit) und Bereichen, in denen Charlotte Vorteile hat.
Vollständige Spezifikation
Siehe docs-internal/CHARLOTTE_SPEC.md für die vollständige Spezifikation einschließlich aller Tool-Parameter, des Seitenrepräsentationsformats, der Elementidentitätsstrategie und der Architekturdetails.
Lizenz
Community
Öffnen Sie einen Fehlerbericht für reproduzierbare Fehler, Regressionen oder MCP-Client-spezifische Probleme.
Öffnen Sie eine Funktionsanfrage für Workflow-Verbesserungen oder neue Fähigkeiten.
Öffnen Sie eine Tool-Anfrage, wenn Sie ein neues Tool, eine Parameteroberfläche oder eine Profilplatzierung vorschlagen möchten.
Durchsuchen Sie offene Issues, um aktuelle Arbeiten und Diskussionen zu finden.
Prüfen Sie den geplanten Good-First-Issue-Filter, da Maintainer einsteigerfreundliche Aufgaben markieren.
Mitwirken
Siehe CONTRIBUTING.md für Richtlinien.
Teil einer wachsenden Suite literarisch benannter MCP-Server. Mehr unter github.com/TickTockBent.
Available Tools
23 toolscharlotte_backA
Navigate back in browser history. Returns page representation after navigation.
Inputs: detail.
charlotte_clickA
Click an interactive element on the page. Returns full page representation after the click.
Inputs: element_id (required), modifiers, click_type.
charlotte_click_atA
Click at specific page coordinates. Use when target elements are not in the accessibility tree (custom widgets, canvas, non-semantic interactive divs). Dispatches real CDP-level mouse events. Returns full page representation after the click.
Inputs: x (required), y (required), modifiers, click_type.
charlotte_diffA
Compare current page state to a previous snapshot. Returns structural diff showing added, removed, moved, and changed elements.
Inputs: scope, snapshot_id.
charlotte_findA
Search for elements matching criteria. Filters interactive elements by text, role, type, or spatial proximity. Use the selector parameter to find DOM elements by CSS selector — this reaches elements not in the accessibility tree (custom widgets, non-semantic divs). Selector results return Charlotte element IDs usable with click, hover, drag, etc.
Inputs: near, role, text, type, +3 more.
charlotte_forwardA
Navigate forward in browser history. Returns page representation after navigation.
Inputs: detail.
charlotte_observeA
Get current page state without performing any action. Use detail levels to control verbosity: "minimal" for landmarks, headings, and interactive element counts by landmark (use charlotte_find to get specific elements with actionable IDs, or observe({ detail: "summary" }) to see all elements), "summary" (default) for content summaries and full element list, "full" for all text content. Use view: "tree" for a compact structural outline (cheapest orientation tool), or view: "tree-labeled" to include labels on interactive elements (still much cheaper than minimal JSON, and shows which button/link/input is which).
Inputs: view, detail, selector, output_file, +1 more.
charlotte_reloadA
Reload the current page. Returns page representation after reload.
Inputs: hard, detail.
charlotte_screenshotA
Capture a visual screenshot. Fallback for when structured representation isn't sufficient (complex visualizations, canvas elements, images). Use save: true to persist as a file artifact that can be referenced later.
Inputs: save, format, quality, selector, +2 more.
charlotte_screenshot_deleteA
Delete a saved screenshot artifact by its ID. Removes the file from disk.
Inputs: id (required).
charlotte_screenshot_getA
Retrieve a previously saved screenshot artifact by its ID. Returns the image data and metadata.
Inputs: id (required).
charlotte_screenshotsA
List all saved screenshot artifacts. Returns metadata for each saved screenshot including ID, filename, page URL, and timestamp.
Inputs: no named parameters.
charlotte_scrollA
Scroll the page or a specific container. Returns full page representation after scrolling.
Inputs: direction (required), amount, element_id.
charlotte_selectA
Select an option in a select/dropdown element. Returns full page representation after selection.
Inputs: value (required), element_id (required).
charlotte_submitB
Submit a form. Can submit by form ID or by clicking its submit button. Returns full page representation after submission.
Inputs: form_id (required).
charlotte_tab_closeA
Close a browser tab by its ID. If the closed tab was active, switches to the first remaining tab.
Inputs: tab_id (required).
charlotte_tab_openA
Open a new browser tab. Optionally navigate to a URL. The new tab becomes the active tab.
Inputs: url.
charlotte_tabsA
List all open browser tabs with their URLs, titles, and active status.
Inputs: no named parameters.
charlotte_tab_switchA
Switch to a different browser tab by its tab ID. Returns the page representation of the activated tab.
Inputs: tab_id (required).
charlotte_toggleA
Toggle a checkbox or switch element. Returns full page representation after toggle.
Inputs: element_id (required).
charlotte_toolsA
Manage Charlotte tool visibility. Lists available tool groups and their status. Use 'enable' or 'disable' to control which tools are loaded. Disabled tools don't appear in the tool list — enable a group to access its tools. Groups: 'interaction' for form filling, clicking, and drag-and-drop. 'session' for cookie/auth management, tab switching, viewport, and network. 'dev_mode' for local development serving and audits. 'evaluate' for JavaScript execution. 'monitoring' for console and network request logs. 'dialog' for JavaScript dialog handling.
Inputs: group, action.
charlotte_typeA
Type text into an input element. Returns full page representation after typing.
Inputs: text (required), element_id (required), slowly, clear_first, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 23 tools
Each tool has a clearly distinct purpose: navigation, tab management, interaction, observation, and screenshot management are all separated. Even similar tools like charlotte_click and charlotte_click_at are explicitly differentiated by target type (element vs coordinates).
All tools share the 'charlotte_' prefix and use snake_case, but there is a mix of simple verbs (navigate, click, type) and compound verb_noun forms (tab_open, screenshot_get). This is mostly consistent but not perfectly uniform.
With 23 tools, the server is on the heavier side but still within a manageable range for a comprehensive browser automation tool. The count is justified by the breadth of features, though it approaches the threshold where it might feel overwhelming.
Core browser automation workflows are well covered: navigation, tab management, element interaction, observation, and screenshot handling. However, the description of charlotte_tools mentions groups for dialogs, drag-and-drop, and session management, but these tools are not present in the exposed set, leaving minor gaps.
Maintenance
Related MCP Connectors
Turn any public website into an MCP server for agents to search, read and navigate.
Web search API and MCP server for developers building AI agents.
Web scraping, browser automation, screenshots and AI data extraction for AI agents via MCP.
Hosted Web Crawler MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server for web scraping and browser automation, enabling AI agents to extract clean, token-efficient content from web pages.1MIT
- AlicenseAqualityDmaintenanceAn MCP server providing AI agents with a stealth Chromium browser that uses hybrid accessibility-object-model and set-of-mark vision for token-lean snapshots and reliable action via ref ids.1373 npm2Apache 2.0
- AlicenseNot gradedqualityBmaintenanceAn MCP server that gives AI agents controlled access to the web, offering unified tools for fetching pages as Markdown, searching across multiple providers, and extracting structured data via CSS selectors.Apache 2.0
- AlicenseNot gradedqualityAmaintenanceGives AI agents token-efficient browser access by returning compact, structured page summaries, targeted element queries, and on-demand detail instead of full accessibility-tree dumps. Supports navigation, interaction, monitoring, and session management through MCP tool profiles.4 npmMIT