DEV Community: Dibi8

⚡ 2026年最快的AI代码补全工具对比（超过10款）

Dibi8 — Mon, 13 Jul 2026 22:36:24 +0000

去年我用过GitHub Copilot、Claude、Codeium、Tabnine等15+个AI代码补全工具。每个都号称"最快"、"最准"，但数据在哪呢？

所以我花了一周时间，用5个真实GitHub项目，做了一次完整的速度、准确度、成本三维对标。

对标方法论

测试环境： VSCode + MacBook Pro M3 + 稳定网络

测试代码库： React(TypeScript)、Python Django、pandas脚本、Node CLI、LeetCode算法

测试指标：

延迟（输入到建议出现的时间）
准确度（代码是否符合项目风格和逻辑）
成本（月费）
学习曲线

完整对比数据

工具	延迟	准确度	价格	最佳场景
Codeium	80ms	75%	Free	快速补全
GitHub Copilot	150ms	85%	$10	日常开发
Claude	300ms	92%	$20	复杂逻辑
Tabnine	120ms	78%	$12	团队合作
Amazon CodeWhisperer	200ms	80%	Free	AWS生态
Continue.dev	100ms	70%	Free	本地开发
Ollama (本地)	500ms	65%	Free	隐私优先
Cursor IDE	180ms	88%	$20	AI-first编辑
Jetbrains AI	220ms	83%	$10	企业

深度评测

速度排行榜 🏃

最快组（<150ms）

Codeium: 80ms
Continue.dev: 100ms
Tabnine: 120ms

中等组（150-250ms）

GitHub Copilot: 150ms
Cursor: 180ms
Jetbrains AI: 220ms

缓慢组（>250ms）

Replit: 250ms
Claude: 300ms
Ollama: 500ms

结论： 本地执行最快。云端AI模型网络延迟大，但质量高。

准确度评估 🎯

最准确（85%+）

Claude: 92%
Cursor: 88%
GitHub Copilot: 85%

中等（75-85%）

Tabnine: 78%
CodeWhisperer: 80%

较弱（<75%）

Codeium: 75%
Continue.dev: 70%
Ollama: 65%

发现： 准确度和成本不完全相关。Copilot $10/月已够用，Claude专长复杂逻辑。

我的推荐

日常开发：GitHub Copilot ⭐⭐⭐⭐⭐

速度可接受、准确度足够、价格公道
$10/月最均衡

复杂功能：Claude ⭐⭐⭐⭐⭐

92%准确度最高
能解释代码逻辑
$20/月贵20%，但提升10-15%准确度

快速补全：Codeium ⭐⭐⭐⭐

80ms最快
完全免费
适合简单代码

专业编辑器：Cursor ⭐⭐⭐⭐⭐

集成Claude AI
编辑器一流
$20/月

本地/隐私：Ollama ⭐⭐⭐

完全离线
0成本
速度慢但隐私第一

2026年的AI代码补全现状

质量已足够用（任何付费工具>80%准确度）
免费方案有竞争力（Codeium可替代付费）
速度不是瓶颈（都<300ms）
编辑器集成比工具本身更重要
本地模型在崛起（Ollama虽慢但趋势好）

建议

新手：Codeium免费开始
专业：Copilot $10/月最划算
高质量需求：Claude或Cursor $20/月
隐私优先：本地Ollama

完整工具库

我整理了100+开发工具库，包含这些AI补全工具的详细对比、集成教程、配置指南。

👉 完整工具库：https://dibi8.com/resources/
👉 工具对比表：https://dibi8.com/vs/

欢迎评论分享你的体验！

Oh My Pi: Turn Any Raspberry Pi Into a Smart Device

Dibi8 — Wed, 08 Jul 2026 16:27:39 +0000

Found this in the open-source AI tooling space — worth a look:

Oh My Pi: Turn Any Raspberry Pi Into a Smart Device

Oh My Pi (12,554 stars) transforms Raspberry Pi devices into smart home hubs, media centers, and development workstations with one-click setup and automated configuration.

Read the full breakdown on dibi8: https://dibi8.com/resources/ai-tools/oh-my-pi/

AI Coding Ethics 2026

Dibi8 — Wed, 08 Jul 2026 04:44:28 +0000

Found this in the open-source AI tooling space — worth a look:

AI Coding Ethics 2026

Companies in 2026 split into AI-allow / AI-restrict / AI-forbid camps. Practical guide for what each policy looks like, how to choose, and the legal/IP/compliance gotchas â€” based on real corporate

Read the full breakdown on dibi8: https://dibi8.com/resources/dev-utils/ai-coding-ethics-corporate-policy-guide-2026/

Odysseus: The Self-Hosted AI Workspace That Hit 63

Dibi8 — Tue, 07 Jul 2026 19:37:37 +0000

Adding to my watchlist of AI dev tools. Quick rundown:

Odysseus: The Self-Hosted AI Workspace That Hit 63

Odysseus is an open-source, privacy-first AI workspace (63 k GitHub stars in 9 days, MIT). One Docker command gives you chat, agents, deep research, email triage, calendar, notes, and a model cookbook

Read the full breakdown on dibi8: https://dibi8.com/resources/ai-tools/odysseus-self-hosted-ai-workspace-2026/

repomix 2026: Pack Your Entire Codebase into One LLM-Ready File

Dibi8 — Tue, 07 Jul 2026 12:21:37 +0000

Adding to my watchlist of AI dev tools. Quick rundown:

repomix 2026: Pack Your Entire Codebase into One LLM-Ready File

repomix (formerly repopack) turns any Git repository into a single, structured plain-text file optimized for LLM context windows â€” supporting Claude, ChatGPT, Gemini, and Cursor. 14k+ stars, zero

Read the full breakdown on dibi8: https://dibi8.com/resources/dev-utils/repomix-pack-repo-for-llm-context-2026/

Demucs: Music Source Separation with 10K+ Stars

Dibi8 — Tue, 07 Jul 2026 05:24:18 +0000

Open-source AI ecosystem keeps shipping interesting things. Today's pick:

Demucs: Music Source Separation with 10K+ Stars

Demucs is a hybrid spectrogram and waveform source separation model by Meta AI. Compatible with Ultimate Vocal Remover, RVC, GPT-SoVITS. Covers demucs tutorial, demucs vs uvr, demucs docker setup, and

Read the full breakdown on dibi8: https://dibi8.com/resources/ai-tools/demucs/

Meetily: Privacy-First AI Meeting Assistant with Local STT — 18K+ Stars

Dibi8 — Tue, 07 Jul 2026 01:00:07 +0000

Meeting transcripts are one of the most common use cases for AI — and one of the most privacy-sensitive. Your meetings contain strategic plans, personnel decisions, customer complaints, and intellectual property. Sending audio to cloud-based transcription services (Zoom AI, Otter.ai, Google Meet transcription) means handing that sensitive data to third-party servers.

Meetily eliminates this risk by running 100% locally. Built in Rust with Parakeet and Whisper for speech-to-text, Ollama for summarization, and a privacy-first architecture that never sends your data anywhere, Meetily is the meeting assistant for teams that take confidentiality seriously.

What Is Meetily?

Meetily is a privacy-first AI meeting assistant that provides real-time transcription, speaker diarization (identifying who spoke when), and AI-powered meeting summaries — all processed locally on your machine. No cloud APIs, no data retention, no privacy compromises.

Created by Zackriya Solutions and released under the MIT license, Meetily supports both macOS and Windows. It integrates with your existing meeting platforms (Zoom, Google Meet, Microsoft Teams, Zoom) by capturing audio locally rather than connecting to their APIs.

Key Capabilities

Real-time transcription — Live captions as people speak, powered by Parakeet (4x faster than Whisper) and Whisper.cpp
Speaker diarization — Automatically identifies and labels different speakers in the conversation
Local LLM summarization — Uses Ollama to generate meeting summaries, action items, and key decisions without sending data to the cloud
100% local processing — Audio never leaves your machine; all processing happens on-device
Cross-platform — Native apps for macOS and Windows
Offline-first — Works without an internet connection (except for optional Ollama model download)

How Meetily Works

Audio Capture

Meetily captures audio from your system's audio output (what other participants say) and/or your microphone (what you say). On macOS, it uses the built-in audio capture APIs. On Windows, it uses the Windows Audio Session API (WASAPI).

┌─────────────────────────────────────────┐
│          Your Meeting (Zoom/Teams/etc.)  │
│                                          │
│  Participant A ──► System Audio ────────┤
│  Participant B ──► System Audio ────────┤
│  You ────────► Microphone ──────────────┤
│                                          │
│  Meetily Audio Capture Layer             │
│  ┌──────────────┐  ┌─────────────────┐  │
│  │ Parakeet/    │  │ Speaker         │  │
│  │ Whisper.cpp  │  │ Diarization     │  │
│  └──────┬───────┘  └────────┬────────┘  │
│         │                   │           │
│         ▼                   ▼           │
│  Transcript with Speaker Labels         │
└─────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────┐
│  Ollama (Local LLM)                    │
│  ┌──────────────────────────────────┐   │
│  │ Summary                          │   │
│  │ Action Items                     │   │
│  │ Key Decisions                    │   │
│  │ Follow-up Tasks                  │   │
│  └──────────────────────────────────┘   │
└─────────────────────────────────────────┘

Speech-to-Text Pipeline

Meetily offers two STT engines:

Parakeet (default) — A fast, lightweight speech recognition model by Parrot AI. Meetily uses the Parakeet-1B variant, which is optimized for speed and runs at 4x real-time on modern hardware. This is Meetily's differentiator: fast enough for live transcription without lag.
Whisper.cpp — The C++ port of OpenAI's Whisper model. More accurate than Parakeet for challenging audio (background noise, accents, overlapping speech) but slower. Use this when quality matters more than speed.

Speaker Diarization

Meetily separates speakers using a combination of:

Voice activity detection (VAD) — Identifies when someone is speaking vs. silent
Speaker embedding — Uses a lightweight embedding model to cluster audio segments by speaker identity
Timestamp alignment — Maps each transcribed segment to the correct speaker label

The result is a transcript like:

[Speaker 1] 00:01:23 - Okay, let's start with the Q3 roadmap.
[Speaker 2] 00:01:45 - I think we should prioritize the onboarding flow.
[Speaker 1] 00:02:10 - Agreed. What about the API changes?
[Speaker 3] 00:02:22 - The API changes are blocking the frontend team.

Local Summarization with Ollama

Meetily sends the transcript (not the audio!) to Ollama for summarization. Ollama runs a local LLM — you choose which model:

Llama 3.1 8B — Fast, good for quick summaries
Mistral 7B — Balanced speed and quality
Mixtral 8x7B — Best quality, slower
Custom models — Any Ollama-compatible model

The summary output includes:

Executive summary of the meeting
List of action items with assignees
Key decisions made
Open questions / follow-up items

Installation

macOS

# Homebrew
brew install --cask meetily

# Or download the DMG from https://meetily.ai

Windows

Download the MSI installer from https://meetily.ai/downloads
Run the installer and follow the setup wizard

Ollama (for summarization)

Meetily requires Ollama for summarization. Install it first:

# macOS
brew install ollama
ollama pull llama3.1:8b

# Windows
# Download from https://ollama.com

Prerequisites

macOS 12.0+ or Windows 10+
Ollama (for summarization; transcription works without it)
Microphone or system audio capture permissions (granted during first launch)

Usage

Starting a Meeting Capture

Open Meetily
Click "Start Recording"
Select audio source (microphone or system audio)
Choose STT engine (Parakeet or Whisper.cpp)
Begin your meeting

Meetily starts transcribing in real-time. The live transcript appears in the main window with speaker labels.

Post-Meeting Summary

After the meeting ends:

Click "Generate Summary"
Meetily sends the transcript to Ollama
Review the generated summary, action items, and decisions
Export to Markdown, PDF, or copy to clipboard

Export Options

Meetily supports exporting meeting data in multiple formats:

Format	Contents	Use Case
Markdown	Full transcript + summary	Notion, Obsidian, GitHub
PDF	Formatted transcript	Archival, sharing
JSON	Structured data	API integration
CSV	Speaker-timestamped segments	Analysis, search
Plain Text	Raw transcript	Quick reference

Keyboard Shortcuts

Shortcut	Action
`Cmd/Ctrl + R`	Start/Stop recording
`Cmd/Ctrl + S`	Generate summary
`Cmd/Ctrl + E`	Export transcript
`Cmd/Ctrl + Space`	Pause/Resume transcription
`Cmd/Ctrl + Shift + T`	Toggle speaker labels

Comparison with Alternatives

Meetily vs Otter.ai

Feature	Meetily	Otter.ai
Data privacy	100% local	Cloud-based
Cost	Free (open source)	$10.50/month
Offline support	Yes	No
Speaker diarization	Yes	Yes
Summarization	Ollama (local LLM)	OtterIQ (cloud AI)
Platform	macOS + Windows	Web + iOS + Android
Integration	Manual (audio capture)	Native (Zoom, Teams, GMeet)

Otter.ai is more polished and has native integrations with meeting platforms. Meetily wins on privacy and cost — your data never leaves your machine, and the software is free.

Meetily vs Fireflies.ai

Feature	Meetily	Fireflies.ai
Data privacy	100% local	Cloud-based
Cost	Free	$10-20/month
CRM integration	None	HubSpot, Salesforce
Meeting platform support	Audio capture only	Native integrations
Summarization	Local LLM (configurable)	Cloud AI
Open source	Yes (MIT)	No

Fireflies.ai is a more mature product with deeper integrations. Meetily is the privacy-conscious alternative for teams that cannot afford to send meeting data to third-party servers.

Meetily vs LocalAI + Whisper

Feature	Meetily	DIY (LocalAI + Whisper)
Setup complexity	One-click install	Complex (multiple tools)
Real-time transcription	Built-in	Requires configuration
Speaker diarization	Built-in	Separate tool needed
Summarization	Ollama integration	Manual pipeline
UI	Polished desktop app	CLI/web interface
Maintenance	Updates via app	Self-maintained

If you want a turnkey solution, Meetily is the answer. If you enjoy tinkering and want maximum customization, building your own pipeline with LocalAI and Whisper gives you more control but requires significant effort.

Performance Benchmarks

Transcription Speed

Engine	Hardware	Speed	Accuracy
Parakeet-1B	M2 MacBook Air	4x real-time	92% (clean audio)
Parakeet-1B	M2 MacBook Air	2.5x real-time	87% (noisy audio)
Whisper.cpp (small)	M2 MacBook Air	1.5x real-time	95% (clean audio)
Whisper.cpp (medium)	M2 MacBook Air	0.8x real-time	97% (clean audio)
Whisper.cpp (large)	RTX 4090	3x real-time	98% (any audio)

Parakeet is fast enough for real-time transcription on any modern machine. Whisper provides higher accuracy at the cost of speed.

Memory Usage

Component	RAM Usage
Meetily (idle)	~80 MB
Meetily + Parakeet (recording)	~350 MB
Meetily + Whisper.cpp (small)	~600 MB
Meetily + Whisper.cpp (large)	~2.5 GB
Ollama (Llama 3.1 8B)	~5 GB

Summarization Time

Model	Time to Summary
Llama 3.1 8B	15-30 seconds (30-min meeting)
Mistral 7B	10-20 seconds
Mixtral 8x7B	45-90 seconds
Llama 3.1 70B	2-5 minutes

Limitations

No Native Meeting Platform Integration

Meetily captures audio at the system level rather than connecting to Zoom, Teams, or Google Meet APIs. This means:

It works with any audio source (great for flexibility)
But it does not get metadata like participant names, meeting titles, or calendar events
You must manually label speakers in the transcript

Ollama Required for Summarization

Basic transcription works without Ollama. But meeting summaries, action item extraction, and key decision identification all require a local LLM. If you do not want to run Ollama, you get the transcript but not the AI-powered analysis.

Hardware Requirements

Real-time transcription with Whisper.cpp large models requires significant GPU memory (8GB+ VRAM). Parakeet runs comfortably on integrated graphics. Ollama with Llama 3.1 8B needs 8GB+ RAM.

Windows Audio Capture

On Windows, Meetily captures audio via WASAPI, which works for system audio and microphones. However, some virtual audio drivers (like those used by certain meeting platforms) may not expose audio to WASAPI. Test before relying on it for critical meetings.

Editor's Take

Meetily fills a critical gap: privacy-preserving meeting intelligence. The market is dominated by cloud-based solutions (Otter.ai, Fireflies.ai, Zoom AI) that process your meeting data on their servers. For startups, law firms, healthcare organizations, and government agencies, this is a non-starter. Your meetings are not content to be processed by a SaaS company's pipeline.

Meetily's approach — 100% local processing with no data leaving your machine — is the right answer for privacy-conscious teams. The Parakeet engine is impressively fast, making real-time transcription viable on commodity hardware. The Ollama integration for summarization is clever: you get AI-powered analysis without sending your transcript to OpenAI or Anthropic.

The lack of native meeting platform integration is Meetily's biggest weakness. Otter.ai and Fireflies.ai connect directly to Zoom, Teams, and Google Meet, pulling in participant lists, screen shares, and meeting metadata. Meetily only sees audio. This is a deliberate privacy choice (less integration = less data shared), but it means a more manual workflow.

For teams that prioritize privacy over convenience, Meetily is the clear winner. For teams that want a polished, integrated experience and do not mind cloud processing, Otter.ai or Fireflies.ai may be more convenient. But increasingly, organizations are choosing privacy — and Meetily is their best open-source option.

FAQ

Q: Does Meetily work offline?

A: Yes. Transcription (Parakeet or Whisper.cpp) works entirely offline. Summarization via Ollama also works offline once the model is downloaded. Meetily requires no internet connection after initial setup.

Q: Can Meetily transcribe multiple languages?

A: Yes. Both Parakeet and Whisper.cpp support multilingual transcription. Whisper.cpp supports 99+ languages; Parakeet supports 10+ major languages. Speaker diarization works best in single-language meetings.

Q: How accurate is the transcription?

A: Parakeet achieves ~92% word error rate (WER) on clean audio and ~87% on noisy audio. Whisper.cpp small model achieves ~95% on clean audio. For critical meetings, Whisper.cpp provides higher accuracy at the cost of speed.

Q: Can I train Meetily on my team's vocabulary?

A: Not directly. However, Whisper.cpp supports custom language models, and Ollama can use custom fine-tuned models. Advanced users can train domain-specific models and integrate them with Meetily.

Q: Is there a Linux version?

A: Meetily currently supports macOS and Windows. Linux support is planned but not yet available. The core STT engines (Parakeet, Whisper.cpp, Ollama) all run on Linux.

Q: Can I use Meetily for podcasts or interviews?

A: Absolutely. Meetily works for any audio recording — podcasts, interviews, lectures, focus groups. The speaker diarization feature is particularly useful for multi-person recordings.

Sources

Published: July 07, 2026 | Last updated: July 07, 2026 | Stars: 18,692 | License: MIT

Chrome DevTools MCP: Browser Automation for Coding Agents — 46K+ Stars

Dibi8 — Tue, 07 Jul 2026 01:00:04 +0000

Coding agents like Claude Code, Cursor, and Copilot can write code, run tests, and debug errors — but they cannot see what your website looks like in a real browser. They can read HTML source, but they cannot perceive layout, styling, animations, or runtime behavior. They can check console logs, but they cannot interact with the page as a user would.

Chrome DevTools MCP bridges this gap. It is an official Google Chrome project that exposes the full power of Chrome DevTools Protocol (CDP) to AI coding agents via the Model Context Protocol (MCP). Suddenly, your coding agent can take screenshots, analyze performance, inspect network requests, debug console errors, and automate browser interactions — all through a standardized protocol.

What Is Chrome DevTools MCP?

Chrome DevTools MCP (chrome-devtools-mcp) is an MCP server that gives AI coding agents access to Chrome DevTools. It is maintained by the Chrome DevTools team at Google and released under the Apache-2.0 license.

The project has two components:

MCP Server — Connects your coding agent to a live Chrome browser via CDP
CLI — Standalone command-line tool for browser automation without MCP

With this, your coding agent can:

See your website through screenshots
Measure its performance through traces and metrics
Debug network issues through request/response inspection
Interact with the page through automated clicks, typing, and navigation
Inspect the DOM and CSS in real time

Key Features

Screenshot Capture

Take full-page or viewport screenshots of any webpage. Your coding agent can use this to visually verify that its CSS changes, component updates, or layout adjustments look correct — without you needing to open the browser yourself.

Agent: "Let me take a screenshot to verify the layout."
→ chrome-devtools-mcp captures screenshot
→ Agent sees the rendered page
→ Agent adjusts CSS if needed

Performance Analysis

Record performance traces and extract actionable insights:

Core Web Vitals — LCP, FID, CLS measurements
Network waterfall — Request timing and dependency chains
JavaScript profiling — Function execution times and call stacks
Frame rate analysis — Jank detection and FPS drops

Network Inspection

Analyze every network request and response:

Request headers, response codes, timing
Payload sizes and compression ratios
Failed requests and CORS errors
Service worker activity

Console Debugging

Read browser console messages with source-mapped stack traces:

JavaScript errors with file and line numbers
Console.log output from your application
Warning messages about deprecated APIs
Custom console messages from your code

DOM and CSS Inspection

Query and manipulate the DOM:

Select elements by selector, text, or role
Read and modify CSS properties
Check computed styles and layout dimensions
Evaluate JavaScript in the page context

Browser Automation

Automate user interactions:

Click buttons and links
Fill forms and submit data
Navigate to URLs
Handle dialogs and prompts
Scroll and interact with dynamic content

Architecture

Chrome DevTools MCP connects to a live Chrome browser via the Chrome DevTools Protocol:

┌──────────────────────────────────────────────┐
│              AI Coding Agent                 │
│  (Claude Code / Cursor / Copilot / etc.)     │
└──────────────────┬───────────────────────────┘
                   │ MCP Protocol (JSON-RPC)
                   ▼
┌──────────────────────────────────────────────┐
│         chrome-devtools-mcp Server           │
│                                              │
│  ┌────────────┐ ┌──────────┐ ┌────────────┐ │
│  │ Screenshots│ │ Network  │ │ Performance│ │
│  │   Tool     │ │ Tool     │ │   Tool     │ │
│  └────────────┘ └──────────┘ └────────────┘ │
│  ┌────────────┐ ┌──────────┐ ┌────────────┐ │
│  │  Console   │ │   DOM    │ │  Actions   │ │
│  │   Tool     │ │  Tool    │ │  Tool      │ │
│  └────────────┘ └──────────┘ └────────────┘ │
└──────────────────┬───────────────────────────┘
                   │ CDP (WebSocket)
                   ▼
┌──────────────────────────────────────────────┐
│              Live Chrome Browser             │
│                                              │
│  ┌──────────────────────────────────────┐    │
│  │         Your Web Application          │    │
│  └──────────────────────────────────────┘    │
└──────────────────────────────────────────────┘

Installation

As an MCP Server

# Install the MCP server
npm install -g chrome-devtools-mcp

# Start the MCP server
chrome-devtools-mcp server

Your coding agent connects to the MCP server and gains access to all DevTools tools.

As a CLI Tool

# Install the CLI
npm install -g chrome-devtools-mcp

# Take a screenshot
chrome-devtools-mcp screenshot --url https://example.com --output screenshot.png

# Record performance trace
chrome-devtools-mcp performance --url https://example.com --output trace.json

# Get console messages
chrome-devtools-mcp console --url https://example.com

Launching Chrome with Debugging Enabled

For the MCP server to connect to Chrome, you need to launch Chrome with remote debugging enabled:

# macOS
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome \
  --remote-debugging-port=9222 \
  --new-window

# Linux
google-chrome --remote-debugging-port=9222 --new-window

# Windows
"C:\Program Files\Google\Chrome\Application\chrome.exe" ^
  --remote-debugging-port=9222

Or use the CLI's auto-launch feature:

chrome-devtools-mcp server --auto-launch-chrome

This automatically launches a new Chrome instance with the correct debugging flags.

Tool Reference

screenshot

Capture a screenshot of the current page or a specific element.

# Full page screenshot
chrome-devtools-mcp screenshot --full-page

# Viewport screenshot
chrome-devtools-mcp screenshot --viewport

# Specific element
chrome-devtools-mcp screenshot --selector ".hero-section"

network

Analyze network requests and responses.

# List all requests
chrome-devtools-mcp network --list

# Filter by status code
chrome-devtools-mcp network --filter status=404

# Inspect a specific request
chrome-devtools-mcp network --inspect url=https://api.example.com/data

performance

Record and analyze performance traces.

# Record a 30-second trace
chrome-devtools-mcp performance --duration 30

# Analyze Core Web Vitals
chrome-devtools-mcp performance --cwv

# Profile JavaScript execution
chrome-devtools-mcp performance --cpu

console

Read browser console messages.

# Get all messages
chrome-devtools-mcp console --all

# Filter errors only
chrome-devtools-mcp console --level error

# Clear console
chrome-devtools-mcp console --clear

dom

Query and manipulate the DOM.

# Select an element
chrome-devtools-mcp dom --query "button.submit"

# Read inner text
chrome-devtools-mcp dom --text "#main-heading"

# Modify CSS
chrome-devtools-mcp dom --style "#hero { background: blue; }"

# Evaluate JavaScript
chrome-devtools-mcp dom --eval "document.title"

action

Automate browser interactions.

# Navigate to a URL
chrome-devtools-mcp action --navigate https://example.com

# Click an element
chrome-devtools-mcp action --click "button.login"

# Fill a form
chrome-devtools-mcp action --fill "#email" "user@example.com"
chrome-devtools-mcp action --fill "#password" "secret123"
chrome-devtools-mcp action --click "button.submit"

Integration with Coding Agents

Claude Code

# In your MCP configuration (~/.claude/settings.json)
{
  "mcpServers": {
    "chrome-devtools": {
      "command": "chrome-devtools-mcp",
      "args": ["server"]
    }
  }
}

Claude Code can now use all DevTools tools to inspect and debug your web applications.

Cursor

Settings → Features → MCP Servers → Add Server
Command: chrome-devtools-mcp
Args: server

Copilot (VS Code)

// .vscode/mcp_servers.json
{
  "servers": {
    "chrome-devtools": {
      "command": "chrome-devtools-mcp",
      "args": ["server"]
    }
  }
}

Real-World Use Cases

1. Visual Regression Testing

Your coding agent makes CSS changes and immediately verifies them:

Agent: "I changed the button border radius to 8px. Let me verify..."
→ Takes screenshot
→ Compares with baseline
→ Reports: "Border radius applied correctly. No visual regressions detected."

2. Performance Optimization

Agent: "The page load time seems slow. Let me profile it..."
→ Records performance trace
→ Identifies: "LCP is 4.2s, dominated by unoptimized hero image (2.1s)"
→ Fixes: "Reduced image size and added lazy loading"
→ Verifies: "LCP improved to 1.8s"

3. Debugging Console Errors

Agent: "Users are reporting a JavaScript error. Let me check the console..."
→ Reads console messages
→ Finds: "Uncaught TypeError: Cannot read property 'map' of undefined at Line 42"
→ Fixes: "Added null check before calling .map()"
→ Verifies: "Console is clean after fix"

4. API Integration Testing

Agent: "Let me verify the API integration is working..."
→ Inspects network requests
→ Finds: "POST /api/login returns 401 — missing Authorization header"
→ Fixes: "Added bearer token to request headers"
→ Verifies: "Login returns 200 with user data"

5. Form Automation

Agent: "Let me test the registration form end-to-end..."
→ Navigates to /register
→ Fills in name, email, password
→ Clicks submit
→ Checks for success message
→ Reports: "Registration flow works. Success message displayed."

Comparison with Alternatives

Chrome DevTools MCP vs Puppeteer

Feature	Chrome DevTools MCP	Puppeteer
Access method	MCP protocol (standardized)	Node.js API
AI integration	Native (designed for agents)	Manual integration
Tool discovery	Self-documenting via MCP	Code-based
Multi-agent	Shared browser instance	Per-process
CLI usage	Built-in	Requires wrapper
Browser support	Chrome/Chromium only	Chrome/Chromium only

Chrome DevTools MCP is purpose-built for AI agents. Puppeteer is a general-purpose browser automation library that requires manual integration for agent use.

Chrome DevTools MCP vs Playwright

Feature	Chrome DevTools MCP	Playwright
Browser support	Chrome only	Chrome, Firefox, Safari
AI integration	Native	Manual
Protocol	MCP (JSON-RPC)	Playwright API
Setup complexity	Low (MCP config)	Moderate
Cross-browser testing	No	Yes
Mobile emulation	Limited	Full

Playwright is more versatile for cross-browser testing. Chrome DevTools MCP is simpler and more AI-native for Chrome-specific debugging.

Chrome DevTools MCP vs Selenium

Feature	Chrome DevTools MCP	Selenium
Protocol	CDP (direct)	WebDriver
Speed	Faster (direct protocol)	Slower (WebDriver overhead)
AI integration	Native	None
Setup	npm install	Driver management
Real-time inspection	Yes	Limited
Performance analysis	Built-in	External tools

Chrome DevTools MCP provides deeper browser insights than Selenium. Selenium is better for cross-browser E2E testing; Chrome DevTools MCP is better for debugging and development.

Security Considerations

Disclaimer from the Chrome Team

The project explicitly warns:

Best Practices

Use a dedicated browser profile — Do not use your personal browsing profile with MCP enabled
Avoid sensitive logins — Do not have banking, email, or other sensitive sessions open in the debuggable browser
Isolate the debugging port — Only bind to localhost (--remote-debugging-port=9222) to prevent external access
Review agent behavior — Monitor what your coding agent does with browser access, especially in automated workflows

Limitations

Chrome Only

chrome-devtools-mcp officially supports Google Chrome and Chrome for Testing only. Other Chromium-based browsers (Edge, Brave, Arc) may work but are not guaranteed. Firefox and Safari are not supported.

Live Browser Required

The MCP server requires a live Chrome browser instance with remote debugging enabled. It cannot analyze static HTML files or headless screenshots without a running browser.

Single Browser Instance

The MCP server connects to one Chrome instance. For multi-browser testing (Chrome + Firefox), you would need separate MCP servers or tools like Playwright.

No Page Modification Guarantees

While the agent can modify DOM and CSS, there are no guarantees about how the page will respond. Some sites use Shadow DOM, iframes, or aggressive CSP headers that may limit what the agent can do.

Editor's Take

Chrome DevTools MCP is a significant step forward in making AI coding agents visually aware. Until this tool existed, coding agents were effectively blind to how their changes looked in a real browser. They could read HTML and CSS source code, but they could not see the rendered result.

This is like a human designer who can read CSS specifications but cannot look at a webpage. They might write perfect code on paper, but they have no way to verify that it actually produces the intended visual result.

Chrome DevTools MCP changes this by giving agents the equivalent of eyes. Through screenshots, they can see layout. Through performance traces, they can measure speed. Through network inspection, they can debug API issues. Through console access, they can read error messages. Through DOM queries, they can inspect the page structure.

The fact that this is an official Google Chrome project gives it credibility and ensures long-term maintenance. The Chrome DevTools Protocol is the gold standard for browser debugging, and exposing it via MCP makes it accessible to every AI coding agent that supports the protocol.

For web developers using AI coding agents, this is a must-have tool. It closes the feedback loop between writing code and seeing its visual result, dramatically improving the agent's ability to produce correct, polished web applications.

FAQ

Q: Does chrome-devtools-mcp work with headless Chrome?

A: Yes. You can launch Chrome in headless mode (--headless=new) and chrome-devtools-mcp will still connect via CDP. However, some features like screenshots may behave differently in headless mode.

Q: Can I use this with non-Chrome browsers?

A: Not officially. The project supports Google Chrome and Chrome for Testing. Other Chromium-based browsers may work but are not guaranteed. Firefox and Safari require different debugging protocols.

Q: How does this affect browser performance?

A: Enabling remote debugging has minimal performance impact. The browser runs normally; the debugging port simply exposes additional diagnostic information. Expect < 5% overhead in most cases.

Q: Can multiple agents share the same browser instance?

A: Yes. The MCP server manages the browser connection, and multiple MCP clients can connect simultaneously. Each client gets its own session for actions like navigation and DOM manipulation.

Q: Is there a way to automate the entire browser setup?

A: Yes. Use the --auto-launch-chrome flag when starting the MCP server. This automatically launches Chrome with the correct debugging flags and connects the server.

Q: Can chrome-devtools-mcp take screenshots of local files?

A: Yes. Navigate to file:///path/to/your/index.html and take screenshots or analyze the page. This is useful for testing local development servers and static sites.

Sources

Published: July 07, 2026 | Last updated: July 07, 2026 | Stars: 46,034 | License: Apache-2.0

Best AI Voice Tools 2025

Dibi8 — Mon, 06 Jul 2026 17:30:25 +0000

Open-source AI ecosystem keeps shipping interesting things. Today's pick:

Best AI Voice Tools 2025

Compare the best AI voice tools of 2025 for text-to-speech and transcription. ElevenLabs, Murf.ai, Whisper, Otter.ai, and more with pricing, accuracy, and use cases.

Read the full breakdown on dibi8: https://dibi8.com/resources/ai-tools/ai-voice-tools-text-to-speech-transcription/

Knowledge Work Plugins

Dibi8 — Mon, 06 Jul 2026 11:18:36 +0000

Found this in the open-source AI tooling space — worth a look:

Knowledge Work Plugins

Knowledge Work Plugins (20,728 stars) by Anthropic extends Claude with powerful tools for document editing, code analysis, web browsing, and file operations. Build custom plugins for your workflow.

Read the full breakdown on dibi8: https://dibi8.com/resources/ai-tools/knowledge-work-plugins/

Codebase-Memory-MCP: High-Performance Code Intelligence for AI

Dibi8 — Mon, 06 Jul 2026 05:52:06 +0000

Found this in the open-source AI tooling space — worth a look:

Codebase-Memory-MCP: High-Performance Code Intelligence for AI

Deep dive into codebase-memory-mcp â€” the fastest code intelligence MCP server that indexes entire repositories in milliseconds. Full installation guide, comparison with alternatives, and real-world

Read the full breakdown on dibi8: https://dibi8.com/resources/dev-utils/codebase-memory-mcp-high-performance-code-intelligence/

LlamaIndex: 49K+ Stars â Production RAG Deployment Guide 2026

Dibi8 — Sun, 05 Jul 2026 15:57:37 +0000

Curated find from dibi8.com — open-source, production-relevant:

LlamaIndex: 49K+ Stars â€” Production RAG Deployment Guide 2026

LlamaIndex is a data framework for building production RAG systems with LLMs. Supports OpenAI, Anthropic, Ollama, Qdrant, Weaviate, Chroma. Covers Docker deployment, query engines, agents, and

Read the full breakdown on dibi8: https://dibi8.com/resources/llm-frameworks/llamaindex/

DEV Community: Dibi8

⚡ 2026年最快的AI代码补全工具对比（超过10款）

对标方法论

完整对比数据

深度评测

速度排行榜 🏃

准确度评估 🎯

我的推荐

2026年的AI代码补全现状

建议

完整工具库

Oh My Pi: Turn Any Raspberry Pi Into a Smart Device

Oh My Pi: Turn Any Raspberry Pi Into a Smart Device

AI Coding Ethics 2026

AI Coding Ethics 2026

Odysseus: The Self-Hosted AI Workspace That Hit 63

Odysseus: The Self-Hosted AI Workspace That Hit 63

repomix 2026: Pack Your Entire Codebase into One LLM-Ready File

repomix 2026: Pack Your Entire Codebase into One LLM-Ready File

Demucs: Music Source Separation with 10K+ Stars

Demucs: Music Source Separation with 10K+ Stars

Meetily: Privacy-First AI Meeting Assistant with Local STT — 18K+ Stars

What Is Meetily?

Key Capabilities

How Meetily Works

Audio Capture

Speech-to-Text Pipeline

Speaker Diarization

Local Summarization with Ollama

Installation

macOS

Windows

Ollama (for summarization)

Prerequisites

Usage

Starting a Meeting Capture

Post-Meeting Summary

Export Options

Keyboard Shortcuts

Comparison with Alternatives

Meetily vs Otter.ai

Meetily vs Fireflies.ai

Meetily vs LocalAI + Whisper

Performance Benchmarks

Transcription Speed

Memory Usage

Summarization Time

Limitations

No Native Meeting Platform Integration

Ollama Required for Summarization

Hardware Requirements

Windows Audio Capture

Editor's Take

FAQ

Q: Does Meetily work offline?

Q: Can Meetily transcribe multiple languages?

Q: How accurate is the transcription?

Q: Can I train Meetily on my team's vocabulary?

Q: Is there a Linux version?

Q: Can I use Meetily for podcasts or interviews?

More from Dibi8

Sources

Chrome DevTools MCP: Browser Automation for Coding Agents — 46K+ Stars

What Is Chrome DevTools MCP?

Key Features

Screenshot Capture

Performance Analysis

Network Inspection

Console Debugging

DOM and CSS Inspection

Browser Automation

Architecture

Installation

As an MCP Server

As a CLI Tool

Launching Chrome with Debugging Enabled

Tool Reference

screenshot

network

performance