Browser MCP

Browser Use MCP Server

Un servidor Model Context Protocol (MCP) rápido y ligero que brinda a los LLM automatización de navegador mediante los datos de accesibilidad estructurados de Puppeteer, con modo de visión opcional para comprensión visual compleja y configuración flexible y multiplataforma.

Características principales

• ⚡ Rápido y ligero. Utiliza el índice de etiquetas de Puppeteer, no entrada basada en píxeles ni el árbol DOM de accesibilidad.
• 👁️ Compatibilidad con modo de visión. Capacidades opcionales de comprensión visual para diseños complejos y elementos visuales cuando los datos estructurados no son suficientes.
• 🤖 Optimizado para LLM. No se necesitan modelos de visión, opera únicamente con datos estructurados, menos contexto reduce el uso de tokens de contexto.
• 🧩 Configuración de ejecución flexible. Personalice el tamaño de viewport, los factores del sistema de coordenadas y el User-Agent en tiempo de ejecución mediante cabeceras HTTP.
• 🌐 Multiplataforma y extensible. Compatibilidad con navegadores remotos y locales, y uso de un motor de navegador personalizado.

Requisitos

• Node.js 18 o superior
• VS Code, Cursor, Windsurf, Claude Desktop o cualquier otro cliente MCP

Primeros pasos

Local (Stdio)

Primero, instale el servidor Browser MCP con su cliente. Una configuración típica tiene este aspecto:

{
  "mcpServers": {
    "browser": {
      "command": "npx",
      "args": [
        "@agent-infra/mcp-server-browser@latest"
      ]
    }
  }
}

# For VS Code
code --add-mcp '{"name":"browser","command":"npx","args":["@agent-infra/mcp-server-browser@latest"]}'

{
  "mcpServers": {
    "browser": {
      "command": "npx",
      "args": [
        "@agent-infra/mcp-server-browser@latest"
      ]
    }
  }
}

{
  "mcpServers": {
    "browser": {
      "command": "npx",
      "args": [
        "@agent-infra/mcp-server-browser@latest"
      ]
    }
  }
}

{
  "mcpServers": {
    "browser": {
      "command": "npx",
      "args": [
        "@agent-infra/mcp-server-browser@latest"
      ]
    }
  }
}

Remoto (SSE / Streamable HTTP)

Al mismo tiempo, usar el argumento --port $your_port para iniciar el navegador mcp permite convertirlo en servidor SSE y Streamable HTTP.

# normal run remote mcp server
npx @agent-infra/mcp-server-browser --port 8089

# run with DISPLAY environment for VNC or other virtual display
DISPLAY=:0 npx @agent-infra/mcp-server-browser --port 8089

Puede usar uno de los dos endpoints remotos del servidor MCP:

• Streamable HTTP (recomendado): http://127.0.0.1::8089/mcp
• SSE: http://127.0.0.1::8089/sse

Y luego, en la configuración del cliente MCP, establezca el url en el endpoint SSE:

{
  "mcpServers": {
    "browser": {
      "url": "http://127.0.0.1::8089/sse"
    }
  }
}

url para Streamable HTTP:

{
  "mcpServers": {
    "browser": {
      "type": "streamable-http", // If there is MCP Client support
      "url": "http://127.0.0.1::8089/mcp"
    }
  }
}

Llamada en memoria

Si su cliente MCP está desarrollado con JavaScript / TypeScript, puede usar directamente llamadas en proceso para evitar que sus usuarios tengan que instalar la interfaz de línea de comandos para usar Browser MCP.

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';

// type: module project usage
import { createServer } from '@agent-infra/mcp-server-browser';
// commonjs project usage
// const { createServer } = await import('@agent-infra/mcp-server-browser')

const client = new Client(
  {
    name: 'test browser client',
    version: '1.0',
  },
  {
    capabilities: {},
  },
);

const server = createServer();
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();

await Promise.all([
  client.connect(clientTransport),
  server.connect(serverTransport),
]);

// list tools
const result = await client.listTools();
console.log(result);

// call tool
const toolResult = await client.callTool({
  name: 'browser_navigate',
  arguments: {
    url: 'https://www.google.com',
  },
});
console.log(toolResult);

Configuración

El servidor Browser MCP admite los siguientes argumentos. Pueden proporcionarse en la configuración JSON anterior, como parte de la lista "args":

> npx @agent-infra/mcp-server-browser@latest -h
  -V, --version              output the version number
  --browser <browser>        browser or chrome channel to use, possible values: chrome, edge, firefox.
  --cdp-endpoint <endpoint>  CDP endpoint to connect to, for example "http://127.0.0.1:9222/json/version"
  --ws-endpoint <endpoint>   WebSocket endpoint to connect to, for example "ws://127.0.0.1:9222/devtools/browser/{id}"
  --executable-path <path>   path to the browser executable.
  --headless                 run browser in headless mode, headed by default
  --host <host>              host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.
  --port <port>              port to listen on for SSE and HTTP transport.
  --proxy-bypass <bypass>    comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"
  --proxy-server <proxy>     specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"
  --user-agent <ua string>   specify user agent string
  --user-data-dir <path>     path to the user data directory.
  --viewport-size <size>     specify browser viewport size in pixels, for example "1280, 720"
  --output-dir <path>        path to the directory for output files
  --vision                   Run server that uses screenshots (Aria snapshots are used by default)
  -h, --help                 display help for command

Configuración de ejecución

El tiempo de ejecución del navegador requiere configuración para Viewport Size, Vision Model Coordinate Factors y User Agent. Estos pueden pasarse mediante las correspondientes cabeceras HTTP:

Nota: Los nombres de las cabeceras no distinguen entre mayúsculas y minúsculas.

Ejemplo:

x-viewport-size: 1920,1080
x-vision-factors: 1.0,1.0
x-user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36

Docker

Hemos unificado la implementación de VNC y MCP bajo un único endpoint de URL. ¡La imagen de Dockerfile y DockerHub se publicarán juntas! vídeo

API

Herramientas

Recursos

Desarrollo

Acceda a http://127.0.0.1:6274/:

npm run dev

Entrada CLI extendida

#!/usr/bin/env node

const {
  BaseLogger,
  setConfig,
  addMiddleware,
} = require('@agent-infra/mcp-server-browser/request-context');

class CustomLogger extends BaseLogger {
  info(...args) {
    console.log('custom');
    console.log(...args);
  }
}

addMiddleware((req, res, next) => {
  console.log('req', req.headers);
  next();
});

setConfig({
  logger: new CustomLogger(),
});

// start server
require('@agent-infra/mcp-server-browser/index');