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

{
  "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

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):

Audio overview (podcast-style)
Video explainer
Infographic
Slide deck
Report
Flashcards
Quiz
Data table
Mind map
(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

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

{
  "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:

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:

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:

Discover available tools via tools/list
Understand input/output formats via schemas
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