Let me be honest with you. The first time I opened Google Antigravity and saw the Agent Manager, I thought I understood what it could do. I typed a prompt, it wrote some code, and I thought – okay, this is like a smarter Copilot. That was wrong.

The real power of Antigravity’s AI agent is not in what it already knows. It’s in what you connect it to. And that connection happens through MCP servers – Model Context Protocol servers. Once you start stacking them in your mcp_config.json, the agent stops being a code generator and starts behaving like a senior engineer who actually understands your project, reads live documentation, and executes real commands.

This guide covers everything: what MCP servers Google Antigravity can use, which ones actually matter, how to configure them without breaking anything, and how to write agent rules so the AI uses them intelligently rather than randomly.

Let’s get into it.

Table of Contents

1. What Is MCP and Why Does Antigravity Need It?
2. How MCP Works Inside Antigravity
   1. The Client-Host-Server Model
   2. Connection Protocols and Transport Layers
3. The 9 Best MCP Servers for Google Antigravity in 2026
   1. Sequential Thinking MCP
   2. Memory Bank MCP
   3. Google Developer Knowledge MCP
   4. Context7 MCP
   5. Brave Search MCP
   6. Bash / Shell MCP
   7. Puppeteer MCP
   8. SQLite and Supabase MCP
   9. Sentry MCP
4. MCP Server Comparison Table
5. How to Add MCP Servers in Google Antigravity: Step by Step
   1. Method 1: Using the MCP Store (GUI)
   2. Method 2: Manual Config via mcp_config.json
6. The Master mcp_config.json File
7. Setting Up GEMINI.md Agent Rules
8. Turbo Mode and Parallel Execution
9. Security and Best Practices
10. Real Use Case: Full Autonomous Development Cycle
11. FAQs About MCP Servers in Antigravity
12. Conclusion

1. What Is MCP and Why Does Antigravity Need It?

The Model Context Protocol (MCP) is an open standard that lets AI models connect securely to external tools, databases, and APIs. Think of it as a standardized plug for AI agents. The same way USB-C works with any device regardless of manufacturer, MCP lets any MCP-compatible AI agent connect to any MCP-compatible tool.

Google Antigravity adopted this standard and built its entire agentic workflow around it. Without MCP servers, Antigravity’s AI is working purely from training data – which, in a world where Next.js releases a new version every few months and Supabase’s API changes regularly, means the agent will eventually write code based on something outdated. Or worse, it’ll confidently hallucinate a function that never existed.

With MCP servers Google Antigravity can connect to, the agent gets live access to:

• Official documentation, so it never uses stale training data
• Your actual database schema, so it writes SQL that works on the first try
• The real web, for current error codes, latest releases, and community answers
• Your terminal, to actually run commands rather than just suggest them
• Your project memory, so it doesn’t forget what you built last week

This is the difference between an AI that guesses and one that knows. And knowing requires MCP.

2. How MCP Works Inside Antigravity

2.1 The Client-Host-Server Model

Before configuring anything, it’s worth understanding the architecture. MCP in Antigravity runs on three components:

• Host: Google Antigravity IDE itself. It manages the agent workflow through the Agent Manager and tells the AI which tools are available at any given time.
• Client: The AI model running inside Antigravity – Gemini 3.1 Pro. It reads your prompt, decides which tool it needs, and sends a JSON-RPC request to the right server.
• Server: A lightweight program that talks directly to an external tool – your database, GitHub, the web – and returns results in a format the AI can read.

Here’s what a real interaction looks like. You type: “Check the users table schema and write a TypeScript function to fetch profile data.” The agent sends a request to your Supabase MCP server, which queries your live database, returns the actual column names, and the agent writes code using full_name instead of guessing username. No browser tabs. No copy-pasting. Code that works.

This is what Antigravity calls “Vibe Coding” – staying in flow while the agent handles the context gathering. MCP is what makes vibe coding actually reliable instead of just fast.

2.2 Connection Protocols and Transport Layers

MCP servers connect to Antigravity using two transport methods:

• stdio (Standard Input/Output): For local servers running on your machine. Data never leaves your system. More secure and lower latency.
• HTTP / Server-Sent Events (SSE): For remote servers like Google Developer Knowledge. Requires API keys sent through secure request headers.

3. The 9 Best MCP Servers for Google Antigravity in 2026

Not all MCP servers are equally useful. Some are genuinely transformative. Others are nice-to-have. Here are the ones worth your time, organized by what they actually do for your workflow.

3.1 Sequential Thinking MCP

Category: Logic and Planning

This is the server I install first on any new project. Without it, the agent often jumps straight into implementation – and halfway through a database migration, you realize it didn’t account for foreign key constraints or an edge case in the auth flow.

The Sequential Thinking MCP changes that behavior. When you hand it a complex task – say, integrating Stripe Checkout with Next.js App Router and Supabase – it creates a hypothesis first, works through each step in order, checks its own reasoning, and revises if something doesn’t hold up. It also decides which other MCP tools to call at each step.

For anything involving architecture design, algorithm planning, or multi-step integrations, this server is non-negotiable. It’s already in the Antigravity MCP Store – just click Install.

3.2 Memory Bank MCP

Category: Context Management

AI models have no memory between sessions by default. Every time you start a new Antigravity session, the agent has zero context about your project. The Memory Bank MCP solves this by maintaining a set of structured Markdown files in your project directory:

• projectbrief.md – what the project does and its goals
• techContext.md – your tech stack, libraries, versions in use
• systemPatterns.md – architectural decisions and patterns you’ve established
• activeContext.md – what’s currently in progress

At the start of every session, the agent runs get-memory-bank-info and immediately knows where things stand. No more re-explaining your project structure every morning or watching the agent make decisions that contradict something you settled two weeks ago.

If you’d prefer vector-based memory with semantic search, Mem0 MCP is the alternative – it stores past decisions in a vector database like Supabase and retrieves relevant context based on meaning rather than exact file reading.

3.3 Google Developer Knowledge MCP

Category: Official Documentation

If you’re building on Firebase, Google Cloud, Android, or Google Maps, this server is critical. Announced in public preview on February 4, 2026, the Google Developer Knowledge MCP connects the agent directly to Google’s official developer documentation – live, not from training data.

It provides two tools: search_documents for pulling relevant snippets, and get_documents for retrieving full pages in clean Markdown. The agent uses whichever it needs without you having to manually find anything.

One important limitation: this server only scans official Google documentation. It doesn’t reach GitHub issues, community blogs, or Stack Overflow answers. For everything outside Google’s ecosystem, you’ll need Brave Search or Firecrawl.

Setup: Requires an API key from Google Cloud Console. The API allows 100 requests per minute at the standard quota.

3.4 Context7 MCP

Category: Third-Party Library Documentation

This is probably the most popular MCP server among Antigravity users right now. Context7 pulls version-specific documentation for frameworks like React 19, Next.js 15, Tailwind CSS, shadcn/ui, and Supabase directly into the agent’s context. The agent never uses a deprecated API call because it’s reading the actual current docs.

With over 50,000 GitHub stars, the community adoption speaks for itself. But there’s something you need to know.

Noma Security recently disclosed a vulnerability called ContextCrush in Context7. Because the server pulls third-party Markdown into the AI’s context, malicious data from external sources can be used for prompt injection – essentially tricking the agent into executing unintended commands through content embedded in a documentation page.

The practical mitigation: while Context7 is pulling external data, don’t have the agent execute write commands (file creation, database writes, terminal commands) without reviewing the results first. Use it for research, not autonomous execution.

3.5 Brave Search MCP

Category: Live Web Research

When the agent needs to find the latest bug fix for a library, check whether a community-reported issue got resolved in a recent release, or research a tool it’s never encountered before, Brave Search gives it that access. It works for both web and local search queries and returns clean results without Google’s scraping restrictions.

Pair it with Firecrawl MCP for scraping specific URLs – Firecrawl strips ads and irrelevant HTML and converts any webpage into clean, LLM-ready Markdown. Together they cover most open-web research needs the agent will ever have.

3.6 Bash / Shell MCP

Category: System Execution

This is what turns Antigravity from a coding assistant into an autonomous developer. With Bash MCP connected, the agent can run npm install, create directories, execute build scripts, run linters, check logs, and do git operations – all on its own. It doesn’t just tell you what to run; it runs it.

That said, this is the riskiest server on this list. An agent with poorly-specified rules and terminal access can delete files, overwrite configs, or execute commands that break your environment – especially if prompt injection is occurring through one of the other servers simultaneously.

Start with the agent set to ask your permission for any write, delete, or destructive operation. Expand autonomy only after you’ve watched it operate correctly in your environment for a while.

3.7 Puppeteer MCP

Category: UI Testing and Browser Automation

The agent can open a real Chrome browser, navigate to your app’s URL, fill in forms, click buttons, and verify that the UI behaves as expected. It captures screenshots or error reports and brings them back into your IDE.

This eliminates the part of development where you have to manually open the browser and test every edge case after each code change. The agent tests its own work before reporting that a feature is complete.

Playwright MCP is the alternative if you prefer Playwright’s testing ecosystem and syntax.

3.8 SQLite and Supabase MCP

Category: Database Access

When you’re building backend features, the agent reads your actual database tables through these servers, runs queries against them, and writes SQL or migration code that matches your real schema. No more writing code that assumes a column name and then discovering the actual column was named differently.

For those building with Google’s Data Cloud – BigQuery, AlloyDB, Spanner, Cloud SQL – these are available directly through the Antigravity MCP Store as part of the MCP Toolbox for Databases. The UI-driven setup means no manual JSON configuration for Google Cloud database connections.

3.9 Sentry MCP

Category: Error Monitoring and Debugging

In traditional debugging, you copy a stack trace from Sentry, paste it into a chat window, and ask the AI what’s wrong. With the Sentry MCP server connected, the agent pulls the full error history, environment context, and related incidents directly from your Sentry project. It then suggests – or makes – the fix itself, without you having to do any manual copy-pasting.

The feedback loop from production error to resolved commit shrinks dramatically. If you’re running any production app, this server is worth setting up.

4. MCP Server Comparison Table

5. How to Add MCP Servers in Google Antigravity: Step by Step

There are two ways to add MCP servers in Antigravity. The first is through the UI – easier but limited to servers in Google’s catalog. The second is through the JSON config file – more powerful and necessary for custom or community servers.

Method 1: Using the MCP Store (GUI)

1. Open Antigravity and locate the Agent Panel on the right side of the interface.
2. Click the “…” (three dots) dropdown at the top of the Agent Panel.
3. Select “MCP Servers” to open the built-in MCP Store.
4. Browse or search for the server you want – Sequential Thinking, Firebase, BigQuery, etc.
5. Click Install and follow any authentication steps the server requires.

Method 2: Manual Config via mcp_config.json

1. In the MCP Store panel, click “Manage MCP Servers”.
2. Click “View raw config” – this opens the mcp_config.json file in your editor.
3. File location by OS:
   • Windows: C:\Users\<USERNAME>\.gemini\antigravity\mcp_config.json
   • Mac / Linux: ~/.gemini/antigravity/mcp_config.json
4. Add your server configuration inside the mcpServers object.
5. Save the file and restart your Antigravity agent session for the changes to take effect.

Critical Security Note: Never hardcode API keys directly in mcp_config.json. If this file gets committed to GitHub accidentally, every key in it is exposed immediately. Use environment variables instead – reference them as ${VARIABLE_NAME} in the JSON, and set the actual values in your system environment settings. On Mac/Linux, that’s ~/.zshrc or ~/.bashrc. On Windows, use System Properties – Environment Variables.

6. The Master mcp_config.json File

Here’s a complete configuration that covers all major workflow categories – planning, memory, documentation, web search, system execution, database, and UI testing. This is the starting point I’d recommend for any serious full-stack project in Antigravity:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "memory-bank": {
      "command": "npx",
      "args": ["-y", "@alioshr/memory-bank-mcp"],
      "env": {
        "MEMORY_BANK_ROOT": "./memory-bank"
      }
    },
    "google-developer-knowledge": {
      "type": "http",
      "url": "https://developerknowledge.googleapis.com/mcp",
      "headers": {
        "X-Goog-Api-Key": "${DEVELOPERKNOWLEDGE_API_KEY}"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"],
      "env": {
        "CONTEXT7_API_KEY": "${CONTEXT7_API_KEY}"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "${BRAVE_API_KEY}"
      }
    },
    "bash-mcp": {
      "command": "npx",
      "args": ["-y", "bash-mcp"]
    },
    "sqlite-mcp": {
      "command": "npx",
      "args": ["-y", "mcp-sqlite", "--db-path", "./project_database.sqlite"]
    },
    "puppeteer-mcp": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"],
      "env": {
        "PUPPETEER_LAUNCH_OPTIONS": "{\"headless\": false}"
      }
    }
  }
}

With this configuration active, the Antigravity agent has a complete development toolbox. It can think through problems step by step, remember your project across sessions, pull live documentation from both Google’s official sources and third-party libraries, search the current web, run shell commands on your machine, query your database directly, and test your UI in a real browser.

That’s not a code assistant. That’s an autonomous development partner. The difference matters when you’re trying to ship something that actually works.

7. Setting Up GEMINI.md Agent Rules

Here’s something most tutorials skip entirely: installing MCP servers is only half the job. If you don’t tell the agent when and how to use them, it’ll use them inconsistently – or skip them altogether and fall back to training data anyway.

Antigravity uses a Markdown-based rules system. You create a GEMINI.md file in your project root and write clear instructions. These rules persist across sessions and apply to every agent interaction within that project.

Here’s a practical GEMINI.md for a project using the full MCP stack above:

# Project Agent Rules

## Memory - Always run first
Before any task, check the memory-bank folder.
If it does not exist, run init-memory-bank.
Always run get-memory-bank-info at session start.

## Planning - Think before coding
For any task with more than 2 implementation steps,
use sequential-thinking to break it into 5-7 logical steps.
Define the expected output for each step before proceeding.
If a step fails, revise reasoning before moving to the next.

## Documentation - Never trust stale training data
For Google services (Firebase, GCP, Android, Maps):
  use google-developer-knowledge.
For third-party frameworks (React, Next.js, Tailwind, Supabase):
  use context7.
If documentation is unavailable in either:
  use brave-search.

## Execution - Ask before destructive actions
After writing code, run lint and build checks via bash-mcp.
Always ask for explicit user confirmation before:
  - Deleting any file or directory
  - Running database migration or seed commands
  - Executing git push or creating pull requests

## Testing - Verify your own work
After any UI feature is complete, use puppeteer-mcp to:
  1. Open the app in a browser session
  2. Test the primary user flow end to end
  3. Screenshot any failures and report them before marking done

These rules turn a general-purpose AI agent into a structured engineering workflow. The agent reads them at the start of each session and treats them as standing orders for how to approach every task in the project.

If you work across multiple AI tools – Antigravity, Claude Code, Cursor – the equivalent global rules file is AGENTS.md, which follows the same format and works across all MCP-compatible agentic IDEs.

8. Turbo Mode and Parallel Execution

Antigravity v1.20.5 introduced Turbo Mode through AgentKit 2.0. It handles situations where manually approving every agent action creates a bottleneck that undermines the whole point of having an autonomous agent.

You control it through directives in workflow files inside .agent/workflows/:

• // turbo – Runs a specific command automatically without asking for approval. Useful for safe, reversible operations like npm install or creating new files.
• // turbo-all – Runs everything in the workflow file without any approval gates. Use carefully.
• // parallel – Executes multiple independent tasks simultaneously. The agent can pull your database schema through SQLite MCP while fetching Next.js docs through Context7 at the same time. According to the Antigravity documentation, this cuts deep research time roughly in half on large projects.
• // retry: 3 – If a network call or tool invocation fails, automatically retry up to 3 times before reporting an error.
• // timeout: 30s – Sets a maximum wait time for a given step before moving on.

Parallel execution is genuinely useful in practice. Database schema reads, documentation fetches, and web searches all run concurrently instead of one after another. For large projects where the agent needs to gather context from multiple sources before starting work, the time savings add up quickly.

9. Security and Best Practices

More capability means more potential for damage when things go wrong. When your AI agent can run shell commands, modify a live database, and browse the web freely, there are real risks that go beyond “it wrote a bug.” These aren’t hypothetical – they’re things that happen when developers get excited and skip the safety configuration.

9.1 Principle of Least Privilege

When you first connect a server like Bash MCP, GitHub MCP, or any database server, give it read-only access. Expand permissions only after you’ve watched the agent operate for a while and you trust how it makes decisions. A new agent with full write access to your production database is dangerous regardless of how capable the underlying model is.

9.2 Environment Variables Only – No Exceptions

Your mcp_config.json is just a text file. If it gets committed to version control accidentally – and this happens more often than you’d think – every API key embedded in it is exposed the moment someone with access to the repo looks at the history. Use environment variable references like ${BRAVE_API_KEY} in the JSON exclusively, and set the actual values in your system environment settings.

9.3 Prompt Injection Through Web Content

When using Brave Search, Firecrawl, or Context7, the agent pulls data from the open web and places it directly into its active context window. Malicious websites can embed instructions in their content designed to trick the agent into executing unintended commands. This is called prompt injection and it’s a documented, real attack vector – not a theoretical one.

The practical defense: while the agent is processing web content from unknown sources, don’t have it run write commands or system operations without your explicit review of the output first.

9.4 Stick to Official or Verified MCP Servers

The MCP ecosystem grew past 10,000 servers in early 2026. Most are community-built. An unofficial MCP server is a program running on your local machine with access to your AI agent’s full context. The risk is obvious. Stick to servers from the official Model Context Protocol repository at modelcontextprotocol.io, or from established companies with verified public repositories – Google, Anthropic, Supabase, GitHub, Stripe.

10. Real Use Case: Full Autonomous Development Cycle

Let me walk you through what an actual session looks like when all these servers are connected and the agent rules are in place. Say you’re building an Inventory Management tool with React, Next.js, and Supabase.

1. You type one prompt: “Build an inventory management tool with React and Supabase. Needs authentication, product CRUD operations, and a real-time dashboard.”
2. Sequential Thinking kicks in first: The agent does not start writing code. It creates a 10-step architecture plan – database schema design first, then RLS policies, then auth setup, then API routes, then UI components. Each step has a defined output and a check before the next begins.
3. Memory Bank records the plan: The full architecture goes into projectbrief.md and systemPatterns.md. Tomorrow’s session starts knowing exactly where things stand.
4. Context7 and Google Developer Knowledge pull live docs: Before writing a single line of Next.js code, the agent fetches the current Next.js 15 routing API. Before any Supabase call, it checks the current Supabase client docs. The code it writes matches the APIs that exist today, not six months ago.
5. Bash MCP runs the scaffolding: The agent creates the project directory structure, runs npx create-next-app, installs Supabase client packages, sets up environment files, and runs the initial database migration – all from your terminal while you watch.
6. SQLite / Supabase MCP verifies the schema: Before writing any data-fetching code, the agent reads your actual table structure and column names. The TypeScript types it generates match your real database.
7. Sentry MCP catches and resolves runtime errors: A runtime error surfaces during development. The agent pulls the full stack trace through Sentry, traces it to the source, patches the file, and verifies the fix with a rebuild.
8. Puppeteer MCP runs end-to-end verification: The agent opens Chrome, logs in with test credentials, creates a product, edits it, checks that the dashboard updates in real time, and deletes it. Screenshots document each step. Any failures get reported before the feature is marked complete.

You were involved at the architecture stage and at approval checkpoints for destructive operations. Everything else – research, coding, execution, testing, debugging – ran autonomously. That’s what a well-configured MCP server stack in Google Antigravity enables.

11. FAQs About MCP Servers in Antigravity

Q1: How many MCP servers can I connect to Antigravity at once?

There’s no hard limit documented by Google, but adding too many servers bloats the agent’s context window and can slow response time. In practice, 8 to 10 active servers is a reasonable ceiling for most projects. If you need more, look at FastMCP Proxy – it bundles multiple servers behind a single MCP interface, keeping your mcp_config.json clean and your context window manageable.

Q2: Do MCP servers slow down Antigravity’s responses?

Remote servers (HTTP-based, like Google Developer Knowledge) add latency per call – typically a few hundred milliseconds each. Local servers using stdio (Sequential Thinking, Memory Bank, Bash) are nearly instant. The // parallel directive in Turbo Mode mitigates remote server latency significantly by running multiple server calls at the same time rather than one after another.

Q3: Is Context7 MCP safe to use?

It’s widely used and genuinely useful for keeping the agent on current library APIs. But use it with caution. The ContextCrush vulnerability documented by Noma Security is real. The practical mitigation: review agent outputs when it has been pulling data from external sources, and don’t grant it write permissions to sensitive resources during those sessions.

Q4: What is the difference between GEMINI.md and AGENTS.md?

GEMINI.md is Antigravity-specific and lives in your project root. It applies only to that specific project. AGENTS.md is a cross-tool standard that works across Antigravity, Claude Code, and other agentic IDEs that have adopted the format. For project-specific rules, use GEMINI.md. For rules you want to apply globally across all your projects and tools, use AGENTS.md in your home directory.

Q5: Can I use multiple MCP servers on Antigravity’s free tier?

Yes. As of April 2026, Antigravity is in public preview and free for personal accounts, with MCP functionality fully available. The external services your servers connect to – Brave Search API, Google Developer Knowledge API, Supabase – have their own free tiers and usage limits that you manage separately.

Q6: What happens to my mcp_config.json when Antigravity updates?

The file lives in your user home directory, not inside the Antigravity application folder, so application updates don’t overwrite it. That said, major version updates can occasionally change the expected config format. Check the Antigravity release notes at antigravity.google/blog after any significant update before your next session.

Q7: Can I build a custom MCP server for Antigravity?

Yes. MCP is a fully open standard. The specification and implementation guides are at modelcontextprotocol.io. You can write a server in Python, TypeScript, or any language that communicates over stdio or HTTP. Anthropic’s engineering team has published a detailed guide on code execution with MCP that covers the patterns and pitfalls of building your own. Custom servers you build follow the same JSON configuration pattern as any other server in your mcp_config.json.

12. Conclusion

Here’s the honest summary of all of this.

Antigravity without MCP servers is a capable AI coding assistant. It writes decent code, it understands your intent, and it’s faster than writing everything yourself. But it’s still just a code generator – it guesses at your database schema, it uses whatever version of React it was trained on, and it can’t actually run anything or verify its own work.

Antigravity with a properly configured MCP server stack is a different thing entirely. It’s closer to having a senior developer who doesn’t sleep, doesn’t forget anything you’ve built, reads the actual current documentation before writing a line, runs its own tests, and fixes the errors it finds. The difference in output quality between the two is substantial.

The setup takes an hour at most. Configure the mcp_config.json, set your environment variables, write a GEMINI.md with clear rules. After that, the compounding benefit runs indefinitely. Every session, the agent knows your project. Every code change, it’s using current documentation. Every feature, it tests itself before telling you it’s done.

Start small if that feels more manageable. Add Sequential Thinking and Memory Bank first – those two alone will noticeably change how the agent approaches work on your project. Then layer in Context7 or Google Developer Knowledge for your specific tech stack. Only connect Bash MCP once you’ve seen how the agent makes decisions in your environment.

The Alt-Tab Dance – leaving your editor to check documentation, copy database schemas, manually test UI flows, paste error messages into chat windows – is optional now. The agent does it. Give it the tools and let it work.

This guide is based on the official Google Antigravity documentation, the Model Context Protocol specification at modelcontextprotocol.io, and direct research into current MCP server configurations and integrations as of April 2026. Bookmark it for future reference – the MCP ecosystem evolves quickly and this page will be updated as the tooling changes.

Download Plan File

Download

Coding AI Agents Prompt:-

“I want to use all the MCP servers given in this file in my Google Antigravity IDE. I have done deep research in the above file. Based on this, I want that when the AI of Antigravity needs the MCP server, it uses it. I want to connect multiple MCP servers. So, you can give me the correct code or research it online or set it yourself. If you cannot do it, then guide me to do the settings.”