{"id":2602,"date":"2025-10-15T13:13:31","date_gmt":"2025-10-15T13:13:31","guid":{"rendered":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2025\/10\/15\/how-to-add-mcp-servers-to-gemini-cli-with-docker-mcp-toolkit\/"},"modified":"2025-10-15T13:13:31","modified_gmt":"2025-10-15T13:13:31","slug":"how-to-add-mcp-servers-to-gemini-cli-with-docker-mcp-toolkit","status":"publish","type":"post","link":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2025\/10\/15\/how-to-add-mcp-servers-to-gemini-cli-with-docker-mcp-toolkit\/","title":{"rendered":"How to add MCP Servers to Gemini CLI with Docker MCP Toolkit"},"content":{"rendered":"

In the rapidly evolving landscape of AI-assisted development<\/a>, most developers continue to struggle with clunky web interfaces, resource-intensive IDEs, and fragmented toolchains. But what if we told you there\u2019s a combination that pairs Google\u2019s 76.3K-star Gemini CLI<\/strong><\/a> (in just 5 months) with Docker\u2019s innovative MCP Toolkit, quietly revolutionizing how modern AI developers work?<\/p>\n

Enter the powerhouse duo: Gemini CLI and <\/strong>Docker MCP Toolkit<\/strong><\/a>. This isn\u2019t just another tool combination \u2014 it\u2019s a paradigm shift that delivers developer AI assistance with zero complexity overhead. A one-time setup of just 5 minutes can save you 20 minutes per test scenario \u2014 that\u2019s a 97% time reduction that compounds with every test you run.<\/p>\n

Let\u2019s look at a concrete example: browser testing and performance analysis that developers do regularly can be simplified and completely automated. What used to require opening browsers, clicking through flows, analyzing DevTools, taking screenshots, and manually documenting buys can now happen in a single 30-second conversation.<\/p>\n

In this guide, you\u2019ll learn how to:<\/p>\n

Set up Gemini CLI and connect it to Docker MCP Toolkit<\/p>\n

Configure the Playwright MCP server<\/a> for browser automation<\/p>\n

Configure the GitHub MCP server<\/a> for issue creation<\/p>\n

Configure the Filesystem MCP server<\/a> for saving test artifacts<\/p>\n

Automate browser testing that discovers real bugs and creates documented GitHub issues<\/p>\n

See how Gemini CLI can analyze performance, capture screenshots, and report findings\u2014all without leaving your terminal<\/p>\n

With 220+ pre-built MCP servers<\/a>, browser automation becomes as simple as having a conversation. No Selenium WebDriver configuration, no CI\/CD pipeline complexity, no manual screenshot management \u2014 just natural language instructions that execute real browser tests.<\/p>\n

Why Gemini CLI and Docker MCP Toolkit Work Better Together<\/h2>\n

Manual browser testing and performance analysis are broken. You open Chrome DevTools, click through pages, check network requests, analyze performance metrics, take screenshots, write bug reports, and then manually create GitHub issues. This context-switching nightmare wastes hours every sprint.<\/p>\n

Traditional automation tools don\u2019t solve the real problem. Selenium requires brittle selectors and a complex setup. Playwright needs JavaScript knowledge and test frameworks. Both require maintaining test scripts that break with every UI change. The \u201csolution\u201d often takes more time than manual testing.<\/p>\n

While Gemini provides powerful AI capabilities and MCP provides the protocol, Docker MCP Toolkit makes browser automation practical. Without containerization, setting up browser testing means managing Chrome\/Firefox installations, dealing with WebDriver versions, configuring Node.js dependencies, handling screenshot directories manually, and different configurations for every developer\u2019s machine. The setup that should take 2 minutes takes 2-6 hours per developer.<\/p>\n

Docker MCP Toolkit eliminates this friction:<\/p>\n

220+ pre-built MCP servers<\/strong> in the catalog<\/p>\n

One-click deployment<\/strong> through Docker Desktop<\/p>\n

Playwright MCP<\/strong> with browsers pre-installed (Chrome, Firefox, WebKit)<\/p>\n

GitHub MCP<\/strong> for automated issue creation<\/p>\n

Filesystem MCP<\/strong> for artifact storage<\/p>\n

Secure credential management<\/strong> via OAuth or encrypted storage<\/p>\n

Consistent configuration<\/strong> across Mac, Windows, and Linux<\/p>\n

Automatic updates<\/strong> when new server versions are released<\/p>\n

We built Docker MCP Toolkit to meet developers where they are. If you\u2019re using Gemini CLI, you should be able to automate browser testing without wrestling with infrastructure.<\/p>\n

Your tests run securely on your machine. Everything executes in isolated Docker containers on your local system. Test data, screenshots, and application access never leave your computer. No cloud uploads, no third-party services, no compliance concerns. You get enterprise-grade browser automation with complete privacy.<\/p>\n

Setting up Gemini CLI in Docker MCP Toolkit<\/h2>\n

Prerequisites<\/h3>\n

Install Docker Desktop<\/a> 4.40 or later<\/p>\n

Enable MCP Toolkit<\/a>\u00a0<\/p>\n

Step 1. Install Gemini CLI<\/h3>\n

Install via npm:<\/p>\n

\nnpm install -g @google\/gemini-cli\n<\/div>\n

Step 2. Launch and authenticate<\/h3>\n

Once installed, just type gemini in your terminal window.<\/p>\n

\ngemini\n<\/div>\n

Step 3. Log in via Google<\/h3>\n

Follow the setup wizard:<\/p>\n

Select a preferred theme style from the options.<\/p>\n

Choose a login method. I recommend \u201cLogin with Google\u201d, which allows up to 60 requests\/minute and 1,000 requests\/day for free<\/p>\n

In case you need higher rate limits or enterprise access, I suggested you use an API key from Google AI Studio<\/a>. You can easily set it as an environment variable:<\/p>\n

\nexport GEMINI_API_KEY=”YOUR_API_KEY”\n<\/div>\n

After selecting your sign-in method, a browser window will open. Simply log in with your Google account<\/p>\n

Step 4. Start chatting with Gemini<\/h3>\n

Just type \u201cgemini\u201d in your terminal window to start chatting with Gemini and enter your prompt.<\/p>\n

<\/div>\n\n

Connect Gemini CLI to Docker MCP Toolkit<\/h4>\n

Option 1: One-Click Connection (Recommended)<\/strong><\/p>\n

Open Docker Desktop<\/p>\n

Navigate to MCP Toolkit<\/strong> in the sidebar<\/p>\n

Click the Clients<\/strong> tab<\/p>\n

Find \u201cGemini\u201d in the list.<\/p>\n

Click Connect<\/strong><\/p>\n

<\/div>\n

Docker Desktop automatically configures the MCP Gateway connection \u2013 the underlying infrastructure that routes requests between Gemini CLI and your MCP servers, handling authentication, containerisation, and secure communication seamlessly.<\/p>\n

Option 2: Manual Command Line Setup<\/strong>
If you prefer a command-line setup or need to configure a specific project:<\/p>\n

Navigate to your project folder in the terminal<\/p>\n

Run this command:<\/p>\n

\ndocker mcp client connect gemini –global\n<\/div>\n

You\u2019ll see output like this:<\/p>\n

\n=== System-wide MCP Configurations ===
\n \u25cf gemini: connected
\n MCP_DOCKER: Docker MCP Catalog (gateway server) (stdio)
\n \u25cf gordon: connected
\n MCP_DOCKER: Docker MCP Catalog (gateway server) (stdio)\n

You might have to restart ‘gemini’.\n<\/p><\/div>\n

The connected status confirms Gemini CLI is linked to the Docker MCP Gateway.<\/p>\n

What\u2019s happening under the hood?<\/h4>\n

The Gemini CLI uses the mcpServers configuration in your settings.json file to locate and connect to MCP servers. This configuration supports multiple servers with different transport mechanisms. The mcpServers object is where you define each MCP server you want the CLI to connect to.<\/p>\n

Whenever you hit the \u201cConnect\u201d button under the Docker MCP Client for Gemini CLI, it adds the following Docker MCP Gateway configuration to the ~\/.gemini\/settings.json file.<\/p>\n

\n{
\n “theme”: “Default”,
\n “selectedAuthType”: “oauth-personal”,
\n “mcpServers”: {
\n “MCP_DOCKER”: {
\n “command”: “docker”,
\n “args”: [“mcp”, “gateway”, “run”],
\n “env”: {}
\n }
\n }
\n}\n<\/div>\n

Learn more about MCP and Gemini CLI interaction through this<\/a> link.<\/p>\n\n

Step 5. Restart Gemini CLI<\/h3>\n
\n# Exit Gemini CLI if running, then restart
\ngemini\n<\/div>\n

Step 6. Verify the Connection<\/h3>\n

Inside Claude Code, type \/mcp to see available MCP servers.\u00a0<\/p>\n

<\/div>\n\n

You should see the Docker MCP Gateway listed, which provides access to all enabled MCP servers. The \/MCP_DOCKER tools indicate a successful connection. As you enable more MCP servers in Docker Desktop, they\u2019ll appear here automatically.<\/p>\n

First Run: What to Expect<\/h3>\n

When you start Gemini CLI for the first time after connecting to Docker MCP Toolkit, you\u2019ll see a prompt about the new MCP server:<\/p>\n

<\/div>\n\n

Choose Option 1<\/strong> (recommended). This configures your project to automatically use Docker MCP Toolkit and any MCP servers you enable in Docker Desktop. You won\u2019t need to approve MCP servers individually each time.<\/p>\n

<\/div>\n\n

You\u2019re now ready to use Gemini with MCP servers from Docker Desktop.<\/p>\n\n

Real-World Demo: Automated Browser Testing and Performance Analysis<\/h2>\n

Now that you\u2019ve connected Gemini CLI to Docker MCP Toolkit, let\u2019s see it in action with a practical example. We\u2019ll automatically discover real bugs through browser testing and identify performance bottlenecks through detailed analysis \u2014 the kind that would take 20 minutes of manual testing, DevTools monitoring, and performance profiling.<\/p>\n

What Makes This Realistic?<\/h3>\n

This isn\u2019t a trivial \u201cHello World\u201d demo. We\u2019re performing comprehensive browser testing and performance analysis on a real e-commerce application with the kinds of issues you encounter in production:<\/p>\n

Uses actual application running on localhost<\/p>\n

Executes functional browser tests (navigation, element inspection, console monitoring)<\/p>\n

Discovers genuine performance bottlenecks through browser DevTools analysis<\/p>\n

Identifies accessibility violations that affect real users<\/p>\n

Captures evidence with screenshots and console logs<\/p>\n

Measures real performance metrics: page load times, network requests, resource usage<\/p>\n

Creates properly formatted GitHub issues with actionable recommendations<\/p>\n

Time investment:<\/h3>\n

Manual process: ~20 minutes (opening browsers, clicking through flows, DevTools analysis, performance profiling, documentation, issue creation)<\/p>\n

Automated with Gemini CLI + MCP: ~30 seconds total<\/p>\n

That\u2019s a 97% time reduction<\/strong>, but more importantly, it\u2019s consistent, thorough, and documented every time.<\/p>\n

What We\u2019re Testing<\/h3>\n

The catalog-service-node application is a realistic e-commerce catalog with intentional issues that mirror common production problems:<\/p>\n

Performance Issues:<\/p>\n

No pagination \u2013 loads all 15 products at once (will degrade with scale)<\/p>\n

Duplicate API calls \u2013 requests \/api\/products twice unnecessarily<\/p>\n

Missing optimization \u2013 unoptimized loading patterns<\/p>\n

Accessibility Issues:<\/p>\n

Missing product images \u2013 placeholder buttons instead of actual images<\/p>\n

Vague button labels \u2013 \u201cFetch\u201d and \u201cUpload\u201d aren\u2019t descriptive for screen readers<\/p>\n

Missing ARIA labels \u2013 table structure not properly announced<\/p>\n

Browser Issues:<\/p>\n

Missing favicon \u2013 generates 404 errors in console<\/p>\n

Console warnings \u2013 duplicate request warnings<\/p>\n

Let\u2019s see if Gemini CLI can discover all of these automatically through intelligent browser testing and performance analysis, then create a comprehensive GitHub issue.<\/p>\n

Step 1: Set Up a Real-World e-Commerce Catalog application<\/h3>\n

For this demo, we\u2019ll use a real e-commerce catalog application. This gives us realistic performance and accessibility issues to discover.<\/p>\n

Clone the repository:<\/strong><\/p>\n

\ngit clone https:\/\/github.com\/ajeetraina\/catalog-service-node
\ncd catalog-service-node\n<\/div>\n

Start all services:<\/strong><\/p>\n

\n# Start Docker services (database, S3, Kafka)
\ndocker compose up -d\n

# Install dependencies
\nnpm install –omit=optional<\/p>\n

# Start the application
\nnpm run dev\n<\/p><\/div>\n

Verify it\u2019s running:<\/strong><\/p>\n

Frontend: http:\/\/localhost:5173<\/a><\/p>\n

API: http:\/\/localhost:3000<\/a><\/p>\n

Step 2: Seed Test Data<\/h3>\n

To make testing realistic, create sample products:<\/p>\n

\n# Create seed script
\ncat > seed-data.sh << ‘EOF’
\n#!\/bin\/bash
\nAPI_URL=”http:\/\/localhost:3000\/api”\n

echo “Seeding test products…”<\/p>\n

curl -s -X POST “$API_URL\/products”
\n -H “Content-Type: application\/json”
\n -d ‘{“name”:”Vintage Camera”,”description”:”Classic 35mm film camera”,”price”:299.99,”upc”:”CAM001″}’
\n > \/dev\/null && echo “\u2705 Vintage Camera”<\/p>\n

curl -s -X POST “$API_URL\/products”
\n -H “Content-Type: application\/json”
\n -d ‘{“name”:”Rare Vinyl Record – LAST ONE!”,”description”:”Limited edition. Only 1 left!”,”price”:149.99,”upc”:”VINYL001″}’
\n > \/dev\/null && echo “\u2705 Rare Vinyl Record”<\/p>\n

curl -s -X POST “$API_URL\/products”
\n -H “Content-Type: application\/json”
\n -d ‘{“name”:”Professional DSLR Camera”,”description”:”50MP camera with 8K video”,”price”:2499.99,”upc”:”CAMPRO001″}’
\n > \/dev\/null && echo “\u2705 Professional DSLR”<\/p>\n

# Add bulk test products
\nfor i in {4..15}; do
\n curl -s -X POST “$API_URL\/products”
\n -H “Content-Type: application\/json”
\n -d “{“name”:”Test Product $i”,”description”:”Bulk test product $i”,”price”:$((50 + RANDOM % 450)).99,”upc”:”BULK$(printf ‘%03d’ $i)”}”
\n > \/dev\/null && echo “\u2705 Test Product $i”
\ndone<\/p>\n

echo “”
\nTOTAL=$(curl -s “$API_URL\/products” | jq ‘. | length’)
\necho “Total products: $TOTAL”
\necho “Ready! Visit http:\/\/localhost:5173”
\nEOF<\/p>\n

chmod +x seed-data.sh
\n.\/seed-data.sh<\/p>\n<\/div>\n

Expected output:<\/strong><\/p>\n

\nSeeding test products…
\n\u2705 Vintage Camera
\n\u2705 Rare Vinyl Record
\n\u2705 Professional DSLR
\n\u2705 Test Product 4
\n\u2705 Test Product 5
\n…
\n\u2705 Test Product 15\n

Total products: 15
\nReady! Visit http:\/\/localhost:5173<\/p>\n<\/div>\n

Now you have a realistic environment with 15 products to analyze.<\/p>\n

Configure MCP Servers<\/h2>\n

For browser testing and performance analysis automation, you\u2019ll orchestrate three MCP servers:<\/p>\n

Playwright MCP<\/a><\/strong> \u2013 Controls browsers, takes screenshots, captures console logs<\/p>\n

GitHub MCP<\/a><\/strong> \u2013 Creates issues automatically with full context<\/p>\n

Filesystem MCP<\/a><\/strong> \u2013 Saves screenshots and test artifacts<\/p>\n

Let\u2019s configure each one.<\/p>\n

Configure Playwright MCP (Browser Automation)<\/h3>\n

The Playwright MCP server gives Gemini the ability to control real browsers, Chrome, Firefox, and WebKit, just like a human would.<\/p>\n

In Docker Desktop:<\/strong><\/p>\n

Open Docker Desktop<\/strong> \u2192 MCP Toolkit<\/strong> \u2192 Catalog<\/strong><\/p>\n

Search for \u201cPlaywright\u201d<\/strong> or \u201cBrowser\u201d<\/strong><\/p>\n

Find Playwright (Browser Automation)<\/strong> in the results<\/p>\n

Click + Add<\/strong><\/p>\n

The server will be added with default configuration (no additional setup needed)<\/p>\n

Click Start Server<\/strong><\/p>\n

What you get:<\/strong><\/p>\n

21+ browser automation tools<\/strong> including:<\/p>\n

browser_navigate \u2013 Navigate to URLs<\/p>\n

browser_snapshot \u2013 Capture page state for analysis<\/p>\n

browser_take_screenshot \u2013 Save visual evidence<\/p>\n

browser_click, browser_type \u2013 Interact with elements<\/p>\n

browser_console_messages \u2013 Get console errors<\/p>\n

browser_network_requests \u2013 Analyze HTTP requests<\/p>\n

<\/div>\n\n

The Playwright MCP runs in a secure Docker container with browsers pre-installed. No manual ChromeDriver setup, no WebDriver conflicts, no OS-specific browser installations.<\/p>\n

Configure GitHub MCP (Issue Creation)<\/h3>\n

The GitHub MCP enables Gemini to create issues, PRs, and manage repositories on your behalf.<\/p>\n

Option 1: OAuth Authentication (Recommended \u2013 Easiest)<\/strong><\/p>\n

In MCP Toolkit<\/strong> \u2192 Catalog<\/strong>, search \u201cGitHub Official\u201d<\/strong><\/p>\n

Click + Add<\/strong><\/p>\n

Go to the OAuth<\/strong> tab in Docker Desktop<\/p>\n

Find the GitHub<\/strong> entry<\/p>\n

Click \u201cAuthorize\u201d<\/strong><\/p>\n

Your browser opens GitHub\u2019s authorization page<\/p>\n

Click \u201cAuthorize Docker\u201d<\/strong> on GitHub<\/p>\n

You\u2019re redirected back to Docker Desktop<\/p>\n

Return to Catalog<\/strong> tab, find GitHub Official<\/strong><\/p>\n

Click Start Server<\/strong><\/p>\n

<\/div>\n\n

Advantage:<\/strong> No manual token creation. Authorization happens through GitHub\u2019s secure OAuth flow with automatic token refresh.<\/p>\n\n

Option 2: Personal Access Token (For Granular Control)<\/strong><\/p>\n

If you prefer manual control or need specific scopes:<\/p>\n\n

Step 1: Create GitHub Personal Access Token<\/strong><\/p>\n

Go to https:\/\/github.com<\/strong><\/a> <\/strong>\u00a0and sign in<\/p>\n

Click your profile picture<\/strong> \u2192 Settings<\/strong><\/p>\n

Scroll to \u201cDeveloper settings\u201d<\/strong> in the left sidebar<\/p>\n

Click \u201cPersonal access tokens\u201d<\/strong> \u2192 \u201cTokens (classic)\u201d<\/strong><\/p>\n

Click \u201cGenerate new token\u201d<\/strong> \u2192 \u201cGenerate new token (classic)\u201d<\/strong><\/p>\n

Name it: \u201cDocker MCP Browser Testing\u201d<\/strong><\/p>\n

Select scopes:<\/strong><\/p>\n

repo (Full control of repositories)<\/p>\n

workflow (Update GitHub Actions workflows)<\/p>\n

Click \u201cGenerate token\u201d<\/strong><\/p>\n

Copy the token immediately<\/strong> (you won\u2019t see it again!)<\/p>\n

Step 2: Configure in Docker Desktop<\/strong><\/p>\n

In MCP Toolkit<\/strong> \u2192 Catalog<\/strong>, find GitHub Official<\/strong><\/p>\n

Click + Add<\/strong> (if not already added)<\/p>\n

Go to Configuration<\/strong> tab<\/p>\n

Select \u201cPersonal Access Token\u201d<\/strong> as the authentication method<\/p>\n

Paste your token<\/p>\n

Click Start Server<\/strong><\/p>\n

Or via CLI:<\/strong><\/p>\n

\ndocker mcp secret set GITHUB.PERSONAL_ACCESS_TOKEN=github_pat_YOUR_TOKEN_HERE\n<\/div>\n

Configure Filesystem MCP (Screenshot Storage)<\/h3>\n

The Filesystem MCP allows Gemini to save screenshots and test artifacts to your local machine.<\/p>\n

In Docker Desktop:<\/strong><\/p>\n

Go to MCP Toolkit<\/strong> \u2192 Catalog<\/strong><\/p>\n

Search for \u201cFilesystem\u201d<\/strong><\/p>\n

Find Filesystem (Reference)<\/strong> and click + Add<\/strong><\/p>\n

Go to the Configuration<\/strong> tab<\/p>\n

Under filesystem.paths<\/strong>, add your project directory:<\/p>\n

Example: \/Users\/yourname\/catalog-service-node<\/p>\n

Or wherever you cloned the repository<\/p>\n

You can add multiple paths by clicking the + button<\/strong><\/p>\n

Click Save<\/strong><\/p>\n

Click Start Server<\/strong><\/p>\n

<\/div>\n

Important Security Note:<\/strong> Only grant access to directories you\u2019re comfortable with Gemini reading and writing to. The Filesystem MCP is scoped to these specific paths for your protection.<\/p>\n\n

Run the Automation<\/h3>\n

Change directory to the root of the catalog-service-node project repository and open Gemini CLI:<\/p>\n

\ngemini\n<\/div>\n

Paste this prompt:<\/p>\n

\nNavigate to http:\/\/host.docker.internal:5173 and perform a detailed
\nperformance and accessibility analysis:\n

1. Take a screenshot of the full page
\n2. Count how many products are displayed
\n3. Open browser DevTools and check:
\n – Console for any JavaScript errors
\n – Network tab: how many HTTP requests are made?
\n – Performance: how long does the page take to load?
\n4. Identify performance issues:
\n – Are all products loading at once with no pagination?
\n – Are images optimized?
\n – Any unnecessary network requests?
\n5. Check for accessibility issues:
\n – Missing alt text on images
\n – Color contrast problems
\n – Vague button labels<\/p>\n

Create a GitHub issue titled “Product catalog performance and
\naccessibility issues” with:
\n– Screenshots attached
\n– List of specific problems found
\n– Severity: Medium
\n– Labels: performance, accessibility, enhancement\n<\/p><\/div>\n

Watch Gemini Work<\/h4>\n

Here\u2019s what happens behind the scenes as Gemini orchestrates multiple MCP servers:<\/p>\n

Step 1: Browser Navigation<\/strong><\/p>\n

\nThe web server is running. I’ll navigate to http:\/\/host.docker.internal:5173, take a screenshot, and then proceed with the rest of the performance analysis.\n<\/div>\n

Gemini launches a real Chromium browser in the Docker container and navigates to your application.<\/p>\n

Step 2: Console Analysis<\/strong><\/p>\n

\n\u2726 I can see 15 products listed on the page: * Vintage Camera * Rare Vinyl Record – LAST ONE! * Professional DSLR Camera * Test Product 4-15\n<\/div>\n

Step 3: Performance Check<\/strong><\/p>\n

\n\u2726 Checking browser console and network requests… Opening DevTools to analyze performance metrics…\n<\/div>\n

Step 4: Issue Creation<\/strong><\/p>\n

\n \u2726 Creating GitHub issue with findings… \n

create_issue (MCP_DOCKER MCP Server) {“labels”:[“performance”,”accessibility”,”enhancement”],”body”:”### Summary…”} <\/p>\n

\u2726 I have successfully created the issue. You can find it at: https:\/\/github.com\/ajeetraina\/catalog-service-node\/issues\/1\n<\/p><\/div>\n

The Complete GitHub Issue<\/h3>\n

Gemini automatically created this comprehensive issue with structured information:<\/p>\n

<\/div>\n\n

Workflow Comparison: Before vs After MCP<\/h4>\n
\n

Step<\/p>\n

Before MCP (Manual Testing)<\/p>\n

Time<\/p>\n

After MCP (Gemini CLI + MCP)<\/p>\n

Time<\/p>\n

1<\/p>\n

Open browser manually<\/p>\n

1 min<\/p>\n

Paste prompt in Gemini CLI<\/p>\n

5 sec<\/p>\n

2<\/p>\n

Navigate to application<\/p>\n

30 sec<\/p>\n

Gemini analyzes automatically<\/p>\n

25 sec<\/p>\n

3<\/p>\n

Click through pages<\/p>\n

3 min<\/p>\n

GitHub issue created<\/p>\n

auto<\/p>\n

4<\/p>\n

Open DevTools manually<\/p>\n

30 sec<\/p>\n

Screenshots attached<\/p>\n

auto<\/p>\n

5<\/p>\n

Take screenshots<\/p>\n

2 min<\/p>\n

\u2713 Complete<\/p>\n

\u2013<\/p>\n

6<\/p>\n

Check browser console<\/p>\n

1 min<\/p>\n

\u2013<\/p>\n

\u2013<\/p>\n

7<\/p>\n

Analyze network requests<\/p>\n

2 min<\/p>\n

\u2013<\/p>\n

\u2013<\/p>\n

8<\/p>\n

Document findings<\/p>\n

3 min<\/p>\n

\u2013<\/p>\n

\u2013<\/p>\n

9<\/p>\n

Write detailed bug report<\/p>\n

5 min<\/p>\n

\u2013<\/p>\n

\u2013<\/p>\n

10<\/p>\n

Create GitHub issue<\/p>\n

2 min<\/p>\n

\u2013<\/p>\n

\u2013<\/p>\n

Summary<\/p>\n

Total<\/p>\n

~ 20 minutes per test<\/p>\n

\u2013<\/p>\n

30 sec per test<\/p>\n<\/div>\n

Time saved per test: 19.5 minutes (97% faster!)<\/p>\n

Impact over time:<\/p>\n

Per day (5 tests): 97 minutes saved \u2192 1.6 hours<\/p>\n

Per week (25 tests): 8 hours saved \u2192 1 full workday<\/p>\n

Per sprint (50 tests): 16 hours saved \u2192 2 full workdays<\/p>\n

Per year (1,000 tests): 325 hours saved \u2192 40 workdays<\/p>\n

Wrapping Up<\/h3>\n

You\u2019ve just witnessed how Docker MCP Toolkit transforms Gemini CLI from a chat assistant into a complete browser testing and performance analysis platform. What used to require opening browsers, clicking through flows, analyzing DevTools, documenting bugs, and creating issues manually now happens in one 30-second conversation.<\/p>\n\n

The combination of Gemini CLI and Docker MCP Toolkit represents a paradigm shift in AI-assisted development. By leveraging terminal-native tools and containerized services, you get:<\/p>\n

Unmatched flexibility<\/strong> in tool selection<\/p>\n

Superior performance<\/strong> with minimal overhead<\/p>\n

Future-proof architecture<\/strong> that scales with your needs<\/p>\n

This setup isn\u2019t just about convenience \u2014 it\u2019s about building a development environment that adapts to your workflow rather than forcing you to adapt to it. The developer productivity revolution is here. The question isn\u2019t whether you\u2019ll adopt AI-assisted development \u2014 it\u2019s whether you\u2019ll lead with the best tools available or play catch-up later.<\/p>\n

Ready to try it? Enable Docker MCP Toolkit<\/a> in Docker Desktop and start building your own Gemini-powered development workflow today.<\/p>\n

Learn more<\/strong><\/h3>\n

Explore the MCP Catalog<\/a>: Discover containerized, security-hardened MCP servers<\/p>\n

Open Docker Desktop and\u00a0get started with the MCP Toolkit<\/a>\u00a0(Requires version 4.48 or newer to launch the MCP Toolkit automatically)<\/em><\/p>\n

Explore our guide on adding MCP Servers to Claude Code with the Docker MCP Toolkit<\/a><\/p>\n

Check out our MCP Horror Stories<\/a> series to see common MCP security pitfalls and how you can avoid them.<\/p>","protected":false},"excerpt":{"rendered":"

In the rapidly evolving landscape of AI-assisted development, most developers continue to struggle with clunky web interfaces, resource-intensive IDEs, and […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[4],"tags":[],"class_list":["post-2602","post","type-post","status-publish","format-standard","hentry","category-docker"],"_links":{"self":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/2602","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/comments?post=2602"}],"version-history":[{"count":0,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/2602\/revisions"}],"wp:attachment":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media?parent=2602"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/categories?post=2602"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/tags?post=2602"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}