Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11To use Chrome DevTools and GitHub through one AI agent, add them as two separate MCP servers in the same compatible MCP host. Chrome DevTools MCP connects the agent to Chrome; GitHub MCP supplies GitHub context and capabilities. The documented setup is not a direct connection from one server to the other.
This distinction matters: an agent can use Chrome to visit a GitHub page, subject to the browser session’s login state, but repository information and GitHub operations require GitHub MCP and its own authentication. Configure and test each integration independently.
What the combined setup does
MCP servers expose capabilities to an MCP host, such as an AI coding environment. In this setup, the host has one server entry for Chrome DevTools MCP and another for GitHub MCP. The host makes both sets of tools available to the agent; neither server needs to connect directly to the other.
- Chrome DevTools MCP: lets the agent work with Chrome and browser inspection workflows. It does not by itself grant access to GitHub’s repository API.
- GitHub MCP: provides GitHub-facing context and capabilities after authentication. It does not control the Chrome browser.
- Your MCP host: launches or connects to the servers and presents their tools to the agent. Configuration syntax and authentication support vary by host.
If the task is to look at a GitHub web page, Chrome can visit it. If the task is to list repositories or perform a GitHub operation, configure GitHub MCP. For a workflow involving both, configure and verify both integrations.
Free tools Windows power users keep installed
One-click scans. No signup required.
#1 Best Overall
Before you configure either server
- Choose an MCP host that supports the server connection types and authentication methods you plan to use. Follow that host’s current configuration instructions; there is no single configuration file format that applies to every host.
- For Chrome DevTools MCP, the listed prerequisites are Node.js LTS, npm, and current stable Chrome or newer. The Chrome DevTools MCP Registry entry provides the requirement details.
- For GitHub MCP, decide whether your host can connect to GitHub’s hosted remote server or whether you need a local server. The local Docker route requires Docker.
- Decide which GitHub permissions the agent needs before authenticating. Use only permissions appropriate to the intended tasks.
Configure Chrome DevTools MCP
1. Add the server to your MCP host
Chrome DevTools MCP is a local-process server. Its project example uses npx and the package chrome-devtools-mcp@latest. Add the server using your host’s documented local-process configuration format, with the equivalent of the following command as its launch command:
npx chrome-devtools-mcp@latestDo not paste this command into a host configuration field without checking that host’s required structure. The server command and the surrounding configuration syntax are separate things: the former is shown here, while the latter is host-specific.
2. Choose how the server reaches Chrome
There are two documented approaches. The right one depends on your Chrome version and whether your host can use the auto-connect mode.
| Approach | Use it when | What to configure |
|---|---|---|
| Auto-connect | You are using Chrome 144 or newer and your MCP host can pass the option. | In Chrome, enable remote debugging at chrome://inspect/#remote-debugging, then pass --autoConnect to Chrome DevTools MCP. |
| Manual remote-debugging URL | You are connecting to a Chrome instance started with remote debugging, or auto-connect is not suitable for your setup. | Start Chrome with remote debugging enabled, then pass --browser-url=http://127.0.0.1:9222 to the server. Use the matching address and port for your Chrome instance. |
The URL shown is the documented example address and port, not a guarantee that every Chrome instance uses that port. Configure the value to match the instance you actually started. The Chrome DevTools MCP instructions also warn that applications on the machine may be able to connect to the debugging port and control the browser; keep that access restricted.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →3. Decide whether to use an existing browser session
Auto-connect can expose an existing Chrome session to the agent. That may include logged-in accounts, cookies, and other session data. Chrome’s guidance is to use this mode only with agents you trust. If that exposure is not acceptable, avoid connecting the agent to a session containing sensitive accounts and choose a browser setup appropriate to your security needs.
Configure GitHub MCP as a second server
Option A: GitHub’s remote server
GitHub documents this remote endpoint:
https://api.githubcopilot.com/mcp/Add it as a separate remote-server entry in your MCP host. This route is convenient when the host supports remote MCP servers and the authentication flow you intend to use. GitHub documents OAuth or a personal access token in an Authorization header, depending on host support.
Authentication is not issued by the endpoint itself. GitHub’s host integration documentation states: “The Remote GitHub MCP Server itself does not provide Authentication services.” You must supply authentication through a supported host flow. Treat the token’s permissions as the agent’s GitHub access, and grant only what the task requires.
Option B: A local GitHub MCP server
If your host cannot connect to GitHub’s remote server, GitHub also documents a local-server option. The available setup includes a Docker image and local stdio authentication options. The Docker route requires Docker; consult GitHub’s repository documentation for the current local setup, token or OAuth details, and permission requirements. Do not assume that local deployment removes the need to authenticate or configure access.
Put both entries in the same host
- Open your MCP host’s server configuration area and add Chrome DevTools MCP as a local process, using the host’s required format and the command
npx chrome-devtools-mcp@latest. - Set its Chrome connection mode: pass
--autoConnectfor the documented Chrome 144-or-newer route, or pass--browser-url=http://127.0.0.1:9222(or the correct URL for your instance) when using manual remote debugging. - Add GitHub MCP as a separate entry. Use
https://api.githubcopilot.com/mcp/if the host supports GitHub’s remote server, or follow GitHub’s local-server instructions if it does not. - Complete GitHub authentication using a flow supported by your host. Confirm that the credentials have only the permissions needed for your intended GitHub tasks.
- Save the configuration and restart or refresh the host if it requires that for new servers to appear.
Because host configuration formats differ, these steps describe the server choices and values rather than a universal JSON or YAML configuration file. Use the host’s current documentation for the exact field names, nesting, and credential-storage method.
Verify Chrome and GitHub independently
A successful connection to one server does not establish that the other is working. Test each integration with an operation appropriate to it:
- Check the server list: confirm that the host reports both Chrome DevTools MCP and GitHub MCP as available. In GitHub Copilot CLI, the documented check is
/mcp show; other hosts provide their own status view. - Test GitHub MCP: ask the agent to list repositories available to the authenticated account. If this fails, investigate GitHub server availability and authentication before changing Chrome settings.
- Test Chrome DevTools MCP: ask the agent to open or inspect a page using the host’s supported Chrome tools. If it cannot reach Chrome, check the selected connection method, Chrome version where relevant, and debugging address and port.
- Test the combined workflow: only after both individual checks work, ask the agent to use browser and GitHub capabilities in one task. Be specific about which part should use the browser and which part requires GitHub MCP.
Choose between the connection options
Chrome: auto-connect or manual remote debugging
Use auto-connect when Chrome is 144 or newer, the host can pass the option, and you are comfortable with the security implications of exposing the connected browser session. Use manual remote debugging when you need to point the server at a specific running Chrome instance or auto-connect is unavailable. Manual setup gives you an explicit address and port to configure, but you must manage that connection and protect the debugging port.
GitHub: remote or local
The remote server avoids running a local GitHub MCP server process, but it depends on your host supporting remote servers and the required authentication method. The local option is useful when remote-server support is unavailable or a local deployment better fits your environment; it adds local setup, and the Docker route requires Docker. In either case, authentication and appropriate permissions remain important.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Security practices for this setup
- Protect browser sessions: connecting Chrome can give an agent access to the state of a logged-in browser. Use only an agent you trust with that session.
- Restrict remote debugging: Chrome DevTools MCP warns that applications on the same machine may connect to the debugging port and control the browser. Avoid exposing that port to untrusted applications or networks.
- Limit GitHub permissions: configure credentials for the narrowest access appropriate to the work. The remote endpoint does not supply or manage authentication for you.
- Keep credentials in the host’s supported secure mechanism: use the host’s guidance rather than putting tokens into prompts or sharing them with browser content.
Troubleshooting
The host does not show Chrome DevTools MCP
Check that the local-process entry uses the host’s required configuration structure and that the command is available in the environment where the host launches it. Confirm Node.js LTS and npm are installed, then restart or refresh the host if necessary.
Chrome does not connect in auto-connect mode
This documented route requires Chrome 144 or newer and remote debugging enabled at chrome://inspect/#remote-debugging. Confirm both conditions and that the server launch includes --autoConnect. If your host cannot use this mode, configure a manually started Chrome instance instead.
The manual Chrome URL does not work
Verify that Chrome was started with remote debugging enabled and that --browser-url points to the actual address and port. The example http://127.0.0.1:9222 works only when that is where the instance is listening. Also check that the host process can reach that address.
Chrome tools work, but GitHub repository access fails
The browser connection and GitHub MCP are separate. Check that the GitHub server is present in the host, that the selected remote or local route is supported, and that authentication completed through the host’s supported flow. Confirm that the credential has access to the requested repositories and sufficient permissions for the requested operation.
GitHub works, but browser inspection fails
GitHub MCP authentication does not configure Chrome. Check the Chrome server entry, launch options, Chrome connection mode, and debugging address separately.
The host cannot use GitHub’s remote server
Check whether the host supports remote MCP connections and its required authentication method. If it does not, use GitHub’s documented local-server option and follow its current setup and authentication instructions.
The agent can open GitHub in Chrome but cannot list repositories
Visiting a web page and querying repository information are different capabilities. The browser may show content available to its session, but repository listing requires a working GitHub MCP connection and valid authorization.
Or skip the browser setup
If your goal is to capture a website rather than interact with a live Chrome session, ScreenshotNeo offers a screenshot API and MCP server. A single GET request can return a PNG, JPEG, WebP, or PDF. Its cleanup options accept cookie or consent banners and remove known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and responses identify the page verdict and billing status in headers. Its MCP server includes take_screenshot, get_page_info, and capture_pdf for compatible AI agents.
Recommended Free Tools
For example, this cURL request captures Stripe as WebP:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for parameters and response details. Free includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots. Learn about ScreenshotNeo, then sign up free for 1,000 screenshots a month with no card.
Frequently Asked Questions
Does Chrome DevTools MCP connect directly to GitHub MCP?
No. The documented arrangement is two independent server entries in one MCP host, with the host exposing both capabilities to the agent.
Can the Chrome server see private GitHub pages?
It can visit pages available to the connected browser session; repository context and GitHub operations require GitHub MCP authorization.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
