Laat je programmeeragent de browser gebruiken waarin je al aangemeld bent.

Wat waar start

Je MCP-client start het npm-pakket als lokaal kindproces via stdio. Dat proces luistert alleen op 127.0.0.1:17374. De extensie belt naar dat proces en voert elke taak via de agentloop van WebBrain in het gekozen browsertabblad uit.

De server is geen tweede browser en kopieert geen cookies. Het is een lokaal doorgeefpunt tussen de MCP-client en de extensie. Het browserprofiel — en dus de geverifieerde sessie — verplaatst zich nooit.

Voor je verbindt

Registreer de server bij je MCP-client

Gebruik eenmalig een van de onderstaande clientspecifieke configuraties. Dit zijn installatiecommando's, niet hoe je browsertaken aanvraagt. Na registratie start de client de server voor je en chat je gewoon door; draai niet tegelijk een handmatige kopie op dezelfde poort.

Codex-app, CLI of IDE-extensie

codex mcp add webbrain -- npx -y @webbrain/mcp-server

Codex slaat MCP-servers op in ~/.codex/config.toml; de app, CLI en IDE-extensie op dezelfde Codex-host delen die configuratie. Geef bij langdurige browsertaken het gereedschap meer tijd dan Codex' standaardbudget per aanroep:

[mcp_servers.webbrain]
command = "npx"
args = ["-y", "@webbrain/mcp-server"]
tool_timeout_sec = 360

Start de app of IDE-extensie opnieuw na het wijzigen van het bestand. Voer in de CLI codex mcp list uit om het item te bevestigen en gebruik /mcp in een Codex-sessie om de verbonden server te inspecteren. Zie de officiële Codex MCP-gids voor de configuratie van gedeelde hosts en alle ondersteunde opties.

Claude Code

claude mcp add --transport stdio webbrain -- npx -y @webbrain/mcp-server

Het expliciete transport komt overeen met de huidige Claude Code MCP-configuratie. Voer na het toevoegen claude mcp list uit om de gezondheid van de server te controleren.

Cursor

Voeg een lokale stdio-server toe in de MCP-instellingen van Cursor, of plaats deze inhoud in het MCP-JSON-bestand dat Cursor gebruikt. Het formaat volgt het Cursor lokale MCP-serverformaat:

{
  "mcpServers": {
    "webbrain": {
      "command": "npx",
      "args": ["-y", "@webbrain/mcp-server"]
    }
  }
}

OpenCode

Voeg dit item toe aan ~/.config/opencode/opencode.json, volgens het lokale MCP-serverformaat van OpenCode:

{
  "mcp": {
    "webbrain": {
      "type": "local",
      "command": ["npx", "-y", "@webbrain/mcp-server"]
    }
  }
}

OpenClaw

Registreer WebBrain in OpenClaw als uitgaande MCP-server. Gebruik voor deze integratie niet openclaw mcp serve: dat commando maakt OpenClaw zelf tot server, de andere richting op.

openclaw mcp add webbrain \
  --command npx \
  --arg -y \
  --arg @webbrain/mcp-server \
  --timeout 360

mcp add peilt de stdio-server af vóór het opslaan. Voer openclaw mcp status --verbose uit om de opgeslagen definitie te inspecteren. Gewone coding- en messaging-toolprofielen bevatten geconfigureerde MCP-servers; het minimal-profiel, een expliciete bundle-mcp-weigering of een sandbox-toerbeleid kan ze verbergen. Zie de OpenClaw MCP-gids voor actuele registry- en beleidsdetails.

Handmatig uitvoeren

Handmatig starten is handig voor het diagnosticeren van de luisteraar, maar niet nodig bij normaal MCP-gebruik:

npx -y @webbrain/mcp-server

Houd die terminal open. Sluiten sluit ook de bridge-luisteraar af. Vanaf een source-checkout voer je binnen mcp-server/ eerst npm install en npm run build uit en daarna npm start.

Wijs WebBrain aan naar de lokale luisteraar

1. Start of herstart je MCP-client. Diens WebBrain-server moet draaien voordat de extensie verbindt.
2. Open de WebBrain-instellingen. Ga naar Instellingen → Bridge.
3. Stel de exacte URL in. Voer ws://127.0.0.1:17374/extension in.
4. Plak de pairing-sleutel. Voer npx -y @webbrain/mcp-server pairing-key uit in een terminal (of open ~/.webbrain/bridge-key) en plak de sleutel in het veld Pairing key. De server vertrouwt alleen een browser die bewijst deze sleutel te bezitten. Ontbreekt het veld, werk WebBrain dan eerst bij.
5. Schakel de cloudbridge in. De status moet van "Verbinden" naar "Verbonden" gaan. De naam is historisch: dit doel is lokaal.
6. Verifieer de verbinding end-to-end. Vraag de MCP-client webbrain_connection aan te roepen. "Connected" bewijst dat client, lokale server, WebSocket-luisteraar en extensie-handshake gereed zijn.

Beschrijf de browsertaak in natuurlijke taal

Schrijf in Codex, Claude Code, Cursor, OpenClaw of OpenCode het verzoek zoals je het een collega zou geven. WebBrain noemen maakt je bedoeling ondubbelzinnig; neem de pagina, het gewenste resultaat, de reikwijdte en of wijzigingen zijn toegestaan mee.

Lezen zonder de pagina te veranderen

Gebruik WebBrain om het Stripe-dashboard dat in mijn browser openstaat te lezen. Noem de mislukte betalingen van de afgelopen zeven dagen met klant, bedrag, valuta, datum en faalreden. Verander niets.

Voorspelbare JSON teruggeven

Extraheer met WebBrain alle achterstallige facturen uit het dashboard dat in mijn browser openstaat. Geef JSON terug met klant, bedrag, valuta, vervaldatum en factuur-URL. Verander niets.

Interactie met de pagina

Open met de Act-modus van WebBrain het klantrecord dat in mijn browser zichtbaar is en werk de bedrijfsnaam bij naar Acme Europe. Stop vóór elke definitieve verzending of bevestiging.

De programmeeragent kiest webbrain_run voor algemeen lezen of interageren en webbrain_extract als je gestructureerde gegevens vraagt. Hij levert de argumenten, monitort de run en presenteert het resultaat van WebBrain terug in het gesprek. Ask-modus kan lezen en extraheren; niet klikken, typen, navigeren of verzenden. Act-modus kan interageren, binnen de normale browsermachtigingen van WebBrain.

webbrain_run(
  task: "read the open Stripe dashboard and list failed payments from the last 7 days with customer, amount, currency, date, and failure reason",
  mode: "ask"
)

Zeg bij taken die interactie vereisen expliciet "gebruik WebBrain in de Act-modus" en houd de browser zichtbaar. WebBrain past zijn normale goedkeuringsprompten per origin toe.

De tools die je MCP-client voor je gebruikt

Jij kiest meestal een resultaat, niet een tool. Je MCP-client leest deze beschrijvingen, kiest de passende tool, vult de invoer ervan aan de hand van je verzoek en handelt vervolgaanroepen af. Deze referentie is er zodat je dit gedrag begrijpt of debugt.

Vraag gestructureerde JSON aan

Zeg in normaal gebruik wat je wilt extraheren en noem de gewenste velden: "extraheer met WebBrain alle achterstallige facturen uit het geopende dashboard en geef JSON terug met klant, bedrag, valuta, vervaldatum en factuur-URL." Een capabele MCP-client kan die velden omzetten naar het vereiste schema en webbrain_extract voor je aanroepen.

Het onderstaande voorbeeld in functievorm toont de equivalente toolaanroep voor clientontwikkelaars en debugging. Beschrijf de selectielogica in task; beschrijf alleen de uitvoervorm in output_schema.

webbrain_extract(
  task: "extract every overdue invoice visible in this account; preserve the displayed currency and use ISO dates where the page provides a full date",
  output_schema: {
    type: "object",
    properties: {
      invoices: {
        type: "array",
        items: {
          type: "object",
          properties: {
            customer: { type: "string" },
            amount: { type: "number" },
            currency: { type: "string" },
            due_date: { type: "string" },
            invoice_url: { type: "string" }
          },
          required: ["customer", "amount", "currency", "due_date"]
        }
      }
    },
    required: ["invoices"]
  }
)

• Gebruik een object-root met expliciete properties en required-velden.
• Vraag de meest beperkte gegevens aan die je nodig hebt. Een schema geeft geen toegang tot gegevens die voor de browsersessie niet zichtbaar zijn.
• De tool is alleen-lezen, maar paginatext en resultaat gaan nog steeds naar de LLM-provider die in WebBrain is ingesteld.
• Als het resultaat te groot is voor de persistente momentopname van de run, meldt de status mogelijk dat het opgeslagen resultaat is ingekort. Verklein het verzoek en probeer opnieuw.

Begrijp de run-levenscyclus

De meeste MCP-clients beheren deze levenscyclus voor je: ze wachten op het resultaat, tonen WebBrains verduidelijkingsvraag wanneer menselijke invoer nodig is, en gaan verder met jouw antwoord. De expliciete aanroepen hieronder zijn handig voor clientontwikkelaars, probleemoplossing of om de client expres een lange taak op de achtergrond te laten starten.

Voorgrondaanroepen wachten standaard. Voor langdurig werk kan de client wait: false instellen en pollen met webbrain_status.

# Toolniveau-referentie
# Start zonder te wachten
webbrain_run(task: "compare the invoices across all visible pages", mode: "ask", wait: false)

# Poll de teruggegeven ID
webbrain_status(run_id: "mcp_…")

Een time-out van een WebBrain-run geeft de controle terug aan de MCP-client maar breekt de browsertaak expres niet af. Poll de teruggegeven run_id. Dit voorkomt dat een time-out de taak stil beëindigt nadat die mogelijk al ingrijpende acties heeft uitgevoerd.

Wanneer WebBrain een vraag stelt

De gepauzeerde momentopname bevat een voor mensen leesbare vraag en een clarify_id. Toon de vraag aan de gebruiker. Stuur hun antwoord woord voor woord door; niet interpreteren.

webbrain_respond(
  run_id: "mcp_…",
  clarify_id: "clarify_…",
  answer: "Use the Acme EU account."
)

Kies de kleinste bevoegdheid

Goedkeuring door de MCP-client en door WebBrain zijn aparte lagen. Je client kan vragen vóór het aanroepen van webbrain_run; WebBrain kan daarna vragen vóór een ingrijpende actie op een bepaald origin. De ene goedkeuring vervangt de andere niet.

Beveiligingsgrenzen die je moet aanhouden

• Houd de luisteraar lokaal. Hij bindt op 127.0.0.1. Forward poort 17374 niet, publiceer hem niet via een containerbridge, en proxy hem niet naar een netwerk.
• Bewaar de pairing-sleutel goed. Loopback op zichzelf is geen authenticatie, dus de server vertrouwt een socket pas nadat die een verse challenge met een HMAC met de pairing-sleutel als sleutel heeft beantwoord; de sleutel zelf gaat nooit over de socket. Wie ~/.webbrain/bridge-key kan lezen, kan paren; plak de sleutel dus niet in een chat. De extensie authenticeert de server niet, dus beschouw lokale code en MCP-pakketten nog steeds als vertrouwde software.
• Gebruik eerst Ask. Alleen-lezen werk is makkelijker te verifiëren en heeft een kleinere slagradius.
• Houd de browser zichtbaar bij Act. Je kunt de run in het zijpaneel stoppen; onverwachte navigatie of typen is een reden om te stoppen.
• Vergeet de providergrens niet. De MCP-bridge blijft lokaal, maar paginainhoud gaat naar de modelprovider die in WebBrain is ingesteld. Gebruik een lokaal model als de content op het apparaat moet blijven.
• Verwar een time-out niet met een rollback. Afbreken stopt volgende stappen; het kan een verzonden e-mail, ingediend formulier, aankoop of andere voltooide actie niet ongedaan maken.

Zie voor het volledige ontwerp het beveiligingsmodel, privacy en gegevensstroom, en de gids over modi, beveiliging en privacy.

Probleemoplossing per symptoom

Omgevingsconfiguratie

Stel voor een stdio-client de omgevingsvariabelen in in de MCP-configuratie van die client. Als je de poort of het pad wijzigt, werk de cloudbridge-URL in de WebBrain-instellingen dan exact bij zodat ze overeenkomen.

Liever LM Studio?

LM Studio gebruikt de aparte WebBrain Web Tools-plug-in, niet dit MCP-pakket. De tools fetch_url en research_url kunnen publieke pagina's lezen zonder de browserextensie; de browsertools kunnen een doel via poort 17375 delegeren aan je aangemelde Chromium-sessie.