---
name: antigravity-mcp-tools
type: reference
title: "MCP Tool Integration — Ghidra, Chrome DevTools, NotebookLM & WebFetch"
description: "Complete inventory and analysis of the 4 MCP servers with 100+ tools integrated into the Antigravity research harness: Ghidra (29), Chrome DevTools (31), NotebookLM (41), and WebFetch (1)."
tags: [antigravity, mcp, ghidra, chrome-devtools, notebooklm, webfetch, reverse-engineering, browser-automation, research-tools]
timestamp: 2026-07-22
---

# MCP Tool Integration — Ghidra, Chrome DevTools, NotebookLM & WebFetch

> **Source:** `/Users/alefita/.gemini/antigravity/mcp_config.json` and per-server tool definitions
> **Total tools:** 100+ across 4 MCP servers
> **Configuration date:** July 1-3, 2026

---

## 1. MCP Architecture Overview

### 1.1 What Is MCP

The **Model Context Protocol** (MCP) is a standard protocol for connecting AI agents to external tools and data sources. It defines:
- A transport layer (Stdio for local processes, SSE for remote servers)
- A tool schema format (JSON Schema for input/output)
- A discovery mechanism (`tools/list`)
- A lifecycle (initialize, call, response)

### 1.2 Global Configuration

```json
{
  "notebooklm": {
    "command": "notebooklm-mcp",
    "status": "disabled"
  },
  "ghidra": {
    "command": "uv run --script /Users/alefita/.lib/ghidra-mcp/bridge_mcp_ghidra.py",
    "status": "active"
  },
  "fitalabs-webfetch": {
    "command": "https://api.unifita.app/mcp",
    "transport": "sse",
    "status": "active"
  }
}
```

| Server | Transport | Status | Tool Count |
|--------|-----------|--------|------------|
| **Ghidra** | Stdio (local Python script) | Active | 29 |
| **Chrome DevTools** | Stdio (local process) | Active | 31 |
| **NotebookLM** | Stdio (CLI binary) | Disabled | 41 |
| **WebFetch** | Stdio (JSON config) | Active | 1 |
| **fitalabs-webfetch** | Remote SSE | Active | 1 (web_fetch) |

### 1.3 Integration Topology

```mermaid
graph TB
    subgraph "Antigravity Agent"
        AGENT[Agent Core]
        MCP_CLIENT[MCP Client]
    end

    subgraph "Local MCP Servers"
        GHIDRA_MCP["Ghidra MCP<br/>(uv run bridge_mcp_ghidra.py)"]
        CDP_MCP["Chrome DevTools MCP<br/>(CDP protocol)"]
        NLM_MCP["NotebookLM MCP<br/>(notebooklm-mcp) [disabled]"]
        WF_MCP["WebFetch MCP"]
    end

    subgraph "Remote MCP Servers"
        FITA["fitalabs-webfetch<br/>(api.unifita.app)"]
    end

    subgraph "External Tools"
        GHIDRA_APP["Ghidra<br/>(Reverse Engineering)"]
        CHROME["Chrome Browser<br/>(DevTools Protocol)"]
        NLM["Google NotebookLM<br/>(Cloud API)"]
    end

    AGENT --> MCP_CLIENT
    MCP_CLIENT -->|"Stdio"| GHIDRA_MCP
    MCP_CLIENT -->|"Stdio"| CDP_MCP
    MCP_CLIENT -->|"Stdio"| NLM_MCP
    MCP_CLIENT -->|"Stdio"| WF_MCP
    MCP_CLIENT -->|"SSE"| FITA

    GHIDRA_MCP <-->|"UDS/TCP"| GHIDRA_APP
    CDP_MCP <-->|"CDP WebSocket"| CHROME
    NLM_MCP <-->|"REST API"| NLM
```

---

## 2. Ghidra MCP Server — 29 Tools

### 2.1 Overview

The Ghidra MCP server provides a complete reverse engineering and debugging toolkit. It connects to running Ghidra instances via Unix Domain Sockets (UDS) or TCP, enabling the agent to import binaries, analyze functions, set breakpoints, and trace execution.

### 2.2 Tool Inventory

#### Instance Management (6 tools)

| Tool | Function | Key Parameters |
|------|----------|---------------|
| `list_instances` | Discover running Ghidra instances via UDS/TCP | None |
| `connect_instance` | Switch to a different Ghidra project | `project` (name) |
| `check_tools` | Verify tool availability | `tools` (comma-separated names) |
| `list_tool_groups` | List all tool categories with counts | None |
| `load_tool_group` | Load all tools in a category | `group` (name or "all") |
| `unload_tool_group` | Unload a tool category | `group` (name) |

#### Binary Import (1 tool)

| Tool | Function | Key Parameters |
|------|----------|---------------|
| `import_file` | Import binary with auto-analysis | `file_path`, `project_folder`, `language`, `compiler_spec`, `auto_analyze` |

Supports ELF, PE, Mach-O, and raw firmware binaries. For raw binaries, the language must be specified (e.g., `ARM:LE:32:Cortex`).

#### Debugger — Full WinDbg Integration (22 tools)

The debugger category provides complete dynamic analysis via the dbgeng (WinDbg) engine:

**Connection:**

| Tool | Function |
|------|----------|
| `debugger_attach` | Attach to a running process by name or PID |
| `debugger_detach` | Detach from the debugged process |
| `debugger_status` | Get connection status, loaded modules, active traces |

**Breakpoints:**

| Tool | Function |
|------|----------|
| `debugger_set_breakpoint` | Set software (INT3) or hardware breakpoint at a Ghidra address |
| `debugger_remove_breakpoint` | Remove breakpoint by ID |
| `debugger_list_breakpoints` | List all active breakpoints with status |

**Execution:**

| Tool | Function |
|------|----------|
| `debugger_continue` | Resume execution until breakpoint or exception |
| `debugger_step_into` | Single-step into calls (configurable count) |
| `debugger_step_over` | Step over calls (configurable count) |

**Inspection:**

| Tool | Function |
|------|----------|
| `debugger_registers` | Read all CPU registers (EAX-EDI, ESP, EBP, EIP, EFLAGS) |
| `debugger_read_memory` | Read memory region as hex dump with DWORD interpretation |
| `debugger_read_args` | Read function arguments based on calling convention |
| `debugger_stack_trace` | Get call stack with return addresses mapped to Ghidra symbols |
| `debugger_modules` | List loaded modules (DLLs) with runtime and Ghidra base addresses |

**Tracing:**

| Tool | Function |
|------|----------|
| `debugger_trace_function` | Non-breaking function tracing (~0.5ms overhead per hit) |
| `debugger_trace_log` | Read trace log with timestamped function calls and arguments |
| `debugger_trace_list` | List all active and completed traces with hit counts |
| `debugger_trace_stop` | Stop a function trace (ID or -1 for all) |

**Watchpoints:**

| Tool | Function |
|------|----------|
| `debugger_watch_memory` | Set hardware watchpoint on memory range (1/2/4 bytes, read/write/readwrite) |
| `debugger_watch_log` | Read watchpoint hit log with values and accessors |
| `debugger_watch_stop` | Stop a watchpoint (ID or -1 for all) |

**Resolution:**

| Tool | Function |
|------|----------|
| `debugger_resolve_ordinal` | Resolve DLL ordinal export to runtime and Ghidra addresses |

### 2.3 Diablo 2 References

The Ghidra MCP tool definitions contain references to Diablo 2-specific entities:
- **DLL:** `D2Common.dll`
- **Symbols:** `pUnit`, `nSkillId`
- **Calling convention:** `__stdcall`

This indicates active game reverse engineering work. Diablo 2 modding and analysis is a well-known RE community activity, and the tool definitions were likely configured with D2-specific parameters for convenience.

### 2.4 Auto-Translation Between Ghidra and Runtime Addresses

A critical feature: the debugger tools **automatically translate** between Ghidra's static analysis addresses and the runtime addresses of the debugged process. When a breakpoint is set at a Ghidra address in `D2Common.dll`, the MCP server calculates the runtime address using the module base address offset:

```
runtime_address = ghidra_address - ghidra_base + runtime_base
```

This eliminates the manual address calculation that normally makes Ghidra-debugger integration painful.

---

## 3. Chrome DevTools MCP Server — 31 Tools

### 3.1 Overview

The Chrome DevTools MCP server provides full browser automation via the Chrome DevTools Protocol (CDP). It enables the agent to navigate pages, fill forms, click elements, take screenshots, monitor network traffic, and run performance traces.

### 3.2 Tool Inventory

#### Navigation (5 tools)

| Tool | Function |
|------|----------|
| `navigate_page` | Navigate to URL |
| `new_page` | Open new tab/page |
| `close_page` | Close a tab/page |
| `select_page` | Switch to a specific tab |
| `list_pages` | List all open tabs |

#### Interaction (9 tools)

| Tool | Function |
|------|----------|
| `click` | Click an element by selector |
| `fill` | Fill a single form field |
| `fill_form` | Fill multiple form fields at once |
| `type_text` | Type text character by character |
| `press_key` | Press a keyboard key (Enter, Tab, etc.) |
| `hover` | Hover over an element |
| `drag` | Drag from one element to another |
| `upload_file` | Upload a file to a file input |
| `handle_dialog` | Accept/dismiss alert/confirm/prompt dialogs |

#### Observation (6 tools)

| Tool | Function |
|------|----------|
| `take_screenshot` | Capture visual screenshot (full page or viewport) |
| `take_snapshot` | Capture DOM state as structured text |
| `take_memory_snapshot` | Capture heap memory snapshot |
| `screencast_start` | Start video screencast |
| `screencast_stop` | Stop video screencast |
| `wait_for` | Wait for element, navigation, or timeout |

#### Network (2 tools)

| Tool | Function |
|------|----------|
| `list_network_requests` | List all network requests with status, type, timing |
| `get_network_request` | Get detailed info for a specific request (headers, body, response) |

#### Console (2 tools)

| Tool | Function |
|------|----------|
| `list_console_messages` | List all console log/warn/error messages |
| `get_console_message` | Get detailed info for a specific console message |

#### Performance (3 tools)

| Tool | Function |
|------|----------|
| `performance_start_trace` | Start performance trace recording |
| `performance_stop_trace` | Stop trace and get results |
| `performance_analyze_insight` | Get AI analysis of performance data |

#### Audit (1 tool)

| Tool | Function |
|------|----------|
| `lighthouse_audit` | Run Lighthouse audit (accessibility, SEO, performance, PWA) |

#### Advanced (3 tools)

| Tool | Function |
|------|----------|
| `evaluate_script` | Execute JavaScript in the page context |
| `emulate` | Emulate device, geolocation, timezone |
| `resize_page` | Resize the browser viewport |

### 3.3 Use Cases in the Research Harness

| Use Case | Tools Used |
|----------|-----------|
| **Buganizer automation** (see [[antigravity-browser-prompting]]) | `navigate_page`, `fill_form`, `click`, `take_snapshot` |
| **Moma search** | `navigate_page`, `fill`, `press_key`, `take_snapshot`, `click` |
| **Web research** | `navigate_page`, `take_snapshot`, `list_network_requests` |
| **Performance analysis** | `performance_start_trace`, `lighthouse_audit` |
| **ClickFix forensics** | `navigate_page` (via Tor), `take_screenshot`, `list_network_requests` |

---

## 4. NotebookLM MCP Server — 41 Tools

### 4.1 Overview

The NotebookLM MCP server provides full programmatic control over Google NotebookLM — a research tool that uses AI to analyze, synthesize, and generate content from uploaded sources. With 41 tools, it is the most extensive MCP integration in the ecosystem.

**Current status:** Disabled in `mcp_config.json`. The `notebooklm-mcp` CLI binary is referenced but not active.

### 4.2 Tool Inventory

#### Notebook Management (6 tools)

| Tool | Function |
|------|----------|
| `create` | Create a new notebook |
| `delete` | Delete a notebook |
| `get` | Get notebook details |
| `list` | List all notebooks |
| `rename` | Rename a notebook |
| `describe` | Set notebook description |

#### Source Management (8 tools)

| Tool | Function |
|------|----------|
| `add` | Add source (URL, text, Google Drive, file, ChatGPT export) |
| `delete` | Delete a source |
| `rename` | Rename a source |
| `describe` | Set source description |
| `get_content` | Get source content |
| `list_drive` | List Google Drive files available for import |
| `sync_drive` | Sync Drive sources for latest content |
| `list` | List all sources in a notebook |

#### Research (3 tools)

| Tool | Function | Key Parameters |
|------|----------|---------------|
| `research_start` | Start research generation | `mode`: "fast" (~30s, ~10 sources) or "deep" (~5min, ~40 sources) |
| `research_status` | Check research progress | `research_id` |
| `research_import` | Import research results as notes | `research_id` |

#### Querying (4 tools)

| Tool | Function |
|------|----------|
| `notebook_query` | Ask a question to a single notebook |
| `notebook_query_start` | Start async query (for long-running) |
| `notebook_query_status` | Check async query status |
| `cross_notebook_query` | Ask a question across multiple notebooks |

#### Studio Artifacts (6 tools)

| Tool | Function |
|------|----------|
| `studio_create` | Generate artifact (10 types, see below) |
| `studio_revise` | Revise an existing artifact |
| `studio_status` | Check generation progress |
| `studio_delete` | Delete an artifact |
| `download_artifact` | Download artifact to local filesystem |
| `export_artifact` | Export artifact to external format |

**Supported artifact types (10):**
1. Audio overview (podcast-style)
2. Video explainer
3. Infographic
4. Slide deck
5. Report
6. Flashcards
7. Quiz
8. Data table
9. Mind map
10. (Custom/studio type)

#### Notes (4 tools)

| Tool | Function |
|------|----------|
| `create` | Create a note |
| `list` | List all notes |
| `update` | Update note content |
| `delete` | Delete a note |

#### Sharing (4 tools)

| Tool | Function |
|------|----------|
| `batch` | Batch share multiple notebooks |
| `invite` | Invite collaborator |
| `public` | Set public access |
| `status` | Get sharing status |

#### System (6 tools)

| Tool | Function |
|------|----------|
| `label` | Label a notebook |
| `tag` | Tag content |
| `note` | Create annotation |
| `pipeline` | Run multi-step pipeline |
| `chat_configure` | Configure chat settings |
| `refresh_auth` / `save_auth_tokens` | Authentication management |
| `server_info` | Get server version and capabilities |

### 4.3 The NLM Skill File

A dedicated skill file at `skills/nlm-skill/SKILL.md` (35,031 bytes) provides comprehensive instructions for using NotebookLM within the research harness. This is the largest single skill file in the ecosystem, reflecting the complexity of the NotebookLM integration.

### 4.4 Research Workflow Example

```mermaid
flowchart TD
    subgraph "Source Ingestion"
        S1["Add URLs as sources"]
        S2["Upload PDFs"]
        S3["Import Google Drive docs"]
    end

    subgraph "Research Phase"
        R1["research_start(mode='deep')"]
        R2["research_status(poll)"]
        R3["research_import(to notes)"]
    end

    subgraph "Query Phase"
        Q1["notebook_query(specific question)"]
        Q2["cross_notebook_query(synthesis question)"]
    end

    subgraph "Artifact Generation"
        A1["studio_create(type='report')"]
        A2["studio_create(type='audio')"]
        A3["studio_create(type='flashcards')"]
        A4["download_artifact"]
    end

    S1 --> R1
    S2 --> R1
    S3 --> R1
    R1 --> R2
    R2 -->|"complete"| R3
    R3 --> Q1
    Q1 --> Q2
    Q2 --> A1
    Q2 --> A2
    Q2 --> A3
    A1 --> A4
```

---

## 5. WebFetch MCP — 1 Tool

### 5.1 Tool Definition

| Tool | Function | Parameters |
|------|----------|-----------|
| `web_fetch` | Fetch URL content as clean markdown | `url` (required), `max_length` (default: 50,000 chars) |

### 5.2 Implementation

The WebFetch MCP server fetches a URL via HTTP GET, parses the HTML response, extracts text content, and returns it as clean Markdown. It handles:
- HTML-to-Markdown conversion
- Character encoding detection
- Content truncation to `max_length`
- Basic JavaScript-rendered content (limited)

### 5.3 Usage Pattern

The agent uses WebFetch for:
- Reading documentation pages
- Fetching API specifications
- Retrieving academic papers
- Accessing raw content from URLs discovered via Chrome DevTools MCP

The 50,000 character default limit is sufficient for most web pages but may truncate long documents.

---

## 6. fitalabs-webfetch — Remote MCP

### 6.1 Configuration

```json
{
  "fitalabs-webfetch": {
    "command": "https://api.unifita.app/mcp",
    "transport": "sse",
    "status": "active"
  }
}
```

This is a remote MCP server hosted at Alefita's own infrastructure (`api.unifita.app`). It uses Server-Sent Events (SSE) transport for persistent connections.

### 6.2 Significance

The existence of a custom MCP server at `api.unifita.app` indicates that Alefita built her own MCP-compatible infrastructure, likely for:
- Custom tool integrations specific to her workflow
- Proxy/gateway to other services
- Secure access to private resources

---

## 7. Cross-Server Integration Patterns

### 7.1 Forensic Analysis Workflow

The ClickFix incident response (see clickfix-handoff) used multiple MCP servers in concert:

```mermaid
flowchart LR
    CDP["Chrome DevTools MCP"] -->|"navigate via Tor"| TARGET["Adversary Infrastructure"]
    CDP -->|"screenshot"| EVIDENCE["Forensic Evidence"]
    CDP -->|"network requests"| IOCs["IOC Extraction"]
    WF["WebFetch MCP"] -->|"fetch WHOIS"| WHOIS["Domain Registration"]
    WF -->|"fetch DNS"| DNS["DNS Records"]
```

### 7.2 Research Workflow

The unit distance research (see unit-distance) used:
- **WebFetch** to access academic papers and OpenAI blog posts
- **NotebookLM** (when enabled) for deep research generation
- **Chrome DevTools** for browsing arXiv and research databases

### 7.3 Reverse Engineering Workflow

The Ghidra MCP enables a complete RE workflow:

```mermaid
flowchart TD
    IMPORT["import_file(binary)"] --> ANALYZE["Auto-analysis"]
    ANALYZE --> BROWSE["Browse functions, data, strings"]
    BROWSE --> ATTACH["debugger_attach(process)"]
    ATTACH --> BP["debugger_set_breakpoint(entry)"]
    BP --> RUN["debugger_continue()"]
    RUN --> INSPECT["debugger_registers() + debugger_read_memory()"]
    INSPECT --> TRACE["debugger_trace_function(key_fn)"]
    TRACE --> LOG["debugger_trace_log()"]
    LOG --> DOCUMENT["Document findings"]
```

---

## 8. Tool Distribution Analysis

### 8.1 By Category

| Category | Tool Count | Percentage |
|----------|-----------|------------|
| NotebookLM | 41 | 41% |
| Chrome DevTools | 31 | 31% |
| Ghidra | 29 | 29% |
| WebFetch | 1 | 1% |
| **Total** | **102** | **100%** |

### 8.2 By Domain

| Domain | Tools | Servers |
|--------|-------|---------|
| **Research & Knowledge** | 42 | NotebookLM, WebFetch |
| **Browser Automation** | 31 | Chrome DevTools |
| **Reverse Engineering & Debugging** | 29 | Ghidra |

### 8.3 Active vs. Disabled

| Status | Servers | Tools |
|--------|---------|-------|
| Active | Ghidra, Chrome DevTools, WebFetch, fitalabs-webfetch | 62 |
| Disabled | NotebookLM | 41 |

The NotebookLM server is the largest but disabled, possibly due to authentication issues, API rate limits, or because it was configured for a specific research session and not needed for ongoing work.

---

## 9. Significance for the Antigravity Ecosystem

### 9.1 The Harness as Laboratory

The 100+ MCP tools transform the Antigravity harness from a conversational AI into a **research laboratory**:
- **Ghidra** provides computational analysis (binary examination, debugging)
- **Chrome DevTools** provides observational capability (web browsing, DOM inspection)
- **NotebookLM** provides knowledge synthesis (research generation, cross-notebook querying)
- **WebFetch** provides data retrieval (URL content extraction)

### 9.2 Domain Independence

The same tool set serves radically different research domains:

| Domain | Tools Used | Sessions |
|--------|-----------|----------|
| Mathematical research | WebFetch, NotebookLM | Unit Distance Season 2 |
| Incident response | Chrome DevTools, WebFetch | ClickFix (session 9f6ac576) |
| Game reverse engineering | Ghidra, Chrome DevTools | Diablo 2 analysis |
| System forensics | Ghidra, Chrome DevTools | Binary analysis |
| Deep research | NotebookLM, WebFetch | Strawberry Deep Research |

### 9.3 The MCP Standard as Enabler

MCP's standardized tool schema means the agent does not need domain-specific training to use these tools. The tool definitions (JSON Schema) provide enough information for the agent to:
1. Discover available tools via `tools/list`
2. Understand input/output formats via schemas
3. Compose tools into workflows (e.g., browse -> extract -> analyze)

This is the key architectural insight: **MCP makes the harness tool-agnostic**. Adding a new tool domain (e.g., database access, API testing, hardware control) requires only a new MCP server, not agent retraining.

---

## Cross-References

- [[antigravity-browser-prompting]] — Browser automation profiles for Buganizer and Moma (powered by Chrome DevTools MCP)
- [[antigravity-hermes-wiki]] — The Hermes agent research wiki that documents the dual-agent MCP bridge architecture
- [[antigravity-strawberry-research]] — The Strawberry Deep Research that was conducted using these tool integrations
- [[antigravity-unified-scheduler]] — The Unified Scheduler Thesis connecting to Ghidra's SHA-256 analysis capabilities
- clickfix-handoff — The ClickFix incident response that used Chrome DevTools and WebFetch for forensic analysis
- unit-distance — The mathematical research that used WebFetch for accessing source materials