Gemini does support the Model Context Protocol, but each surface handles it differently. This article compares Gemini CLI, the Gemini API and SDK, managed agents, the Gemini app and Gemini Enterprise, with config fields, commands, limits and a working Python snippet.
Yes, Gemini supports the Model Context Protocol, but the answer changes with the door you walk through. Gemini CLI treats MCP as a built-in feature. The Gemini API reaches it through an experimental SDK client and, in preview, through managed agents. The Gemini app accepts remote servers only for a narrow group of users, and Gemini Enterprise leaves the setup to administrators. If three forum threads gave you three different answers, they were probably all correct about different products.
This article walks through each route using what Google documents as of October 2026. You will see which route runs a local process, which one needs a public HTTPS address, where the model limits sit, and which accounts can use each option. There is a working settings file, a Python snippet, a decision table and a short list of mistakes that waste the most time.
MCP, the Model Context Protocol, is an open standard that lets an AI assistant call tools and read resources from a separate server. You write a server once, and any MCP client can use it. Gemini plays the client role in five different shapes, and each one has its own rules about where the server lives, who signs in and what the model is allowed to touch.
| Surface | MCP support | Server location | Status |
|---|---|---|---|
| Gemini CLI | Built in | Local process or remote URL | Documented |
| Gemini API with Python and JS SDKs | Session passed as a tool | Wherever your code can connect | Experimental |
| Gemini API managed agents | mcp_server tool | Remote servers | Preview |
| Gemini app, web and mobile | Custom apps | Remote HTTPS servers | Limited eligibility |
| Gemini Enterprise | Custom MCP server | Remote servers | Admin setup |
💡 Quick rule: only Gemini CLI and your own SDK code can launch a local MCP server. Every other route needs a URL.
Gemini CLI is the most capable MCP client in the family. It speaks three transports (stdio, SSE and streamable HTTP), and it exposes more than tools: server resources and prompts show up inside the session too. For anyone testing a new server, this is the shortest path from idea to working call.
The CLI ships a small command family for managing servers:
gemini mcp add [options] <name> <commandOrUrl> [args...]
gemini mcp list
gemini mcp remove <name>
gemini mcp enable <name>
gemini mcp disable <name>
gemini mcp list prints every configured server with its connection status, which makes it the fastest sanity check after an edit. If you prefer editing by hand, servers live in the mcpServers object of your settings.json, either at user level (~/.gemini/settings.json) or at project level (.gemini/settings.json):
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "./docs"],
"timeout": 30000
},
"remote-tools": {
"httpUrl": "https://example.com/mcp",
"headers": { "Authorization": "Bearer YOUR_TOKEN" },
"includeTools": ["search_docs"]
}
}
}
The first entry launches a local server over stdio. The second talks to a remote server over streamable HTTP and exposes a single tool, which keeps the model's options small and predictable.
Every server entry needs one transport field. Everything else is optional:
command: the executable for a local stdio server, with args, cwd and env beside it. Values in env can reference variables with $VAR_NAME, so tokens stay out of the file.url: an SSE endpoint.httpUrl: a streamable HTTP endpoint.headers: custom HTTP headers for the two URL transports.timeout: request timeout in milliseconds, 600,000 by default.includeTools and excludeTools: an allowlist and a blocklist for tool names.trust: when true, tool confirmation dialogs are skipped.authProviderType: picks the auth provider: automatic OAuth endpoint lookup, Google credentials (google_credentials) or service account impersonation (service_account_impersonation).💡 Leave
trustoff for any server you did not write yourself. The confirmation dialog is the last checkpoint before a tool runs.
Once the CLI is running, /mcp shows each server's status, tools, resources and prompts. /mcp auth [serverName] handles OAuth, and /mcp enable and /mcp disable toggle a server for the current session only.
A few behaviors surprise people the first time:
mcp_{serverName}_{toolName}, which prevents collisions between servers and built-in tools.@server://resource/path inside your prompt.~/.gemini/mcp-oauth-tokens.json, and Google Application Default Credentials are supported as well.The Gemini API does not open connections to your server by itself. The SDK does. It connects to the server, asks for its tool list, and hands those tools to the model as callable functions. In the python-genai repository, Google describes this built-in MCP support as an experimental feature, and the example is marked for the Gemini Developer API only, not for the Enterprise Agent Platform.
The pattern needs the mcp package next to google-genai. You open a client session against a server, then pass that session straight into the generation config:
import asyncio
from google import genai
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
client = genai.Client() # reads the API token from the environment
server = StdioServerParameters(
command="npx",
args=["-y", "@modelcontextprotocol/server-filesystem", "./docs"],
)
async def main():
async with stdio_client(server) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
response = await client.aio.models.generate_content(
model="gemini-flash-latest",
contents="List the markdown files in the docs folder.",
config=genai.types.GenerateContentConfig(tools=[session]),
)
print(response.text)
asyncio.run(main())
Because your code holds the session, the connection runs inside your own process. That is why this route works with local servers. The price is lifecycle work: you open the session, initialize it, make the call and close it again.
On July 7, 2026, Google announced remote MCP for managed agents in the Gemini API. Instead of writing proxy middleware, you pass an mcp_server tool at interaction time, next to tools such as Google Search or code execution. Credentials travel through custom headers, so an Authorization header can protect your endpoint. The agent then calls your endpoints from its own secure sandbox.
The announcement's examples use the agent antigravity-preview-05-2026, and the feature is in preview, so expect details to shift.
The Interactions API overview lists a limitation in plain words: Gemini 3 does not support remote MCP, and the page says it is coming soon. Google describes managed agents and the plain model path as separate capabilities, so read the limits of the exact surface you call. The SDK route above is different again, since the connection lives in your code, but test it with your target model before you build on it.
💡 When a doc page and an announcement seem to disagree, check the date. Preview features move quickly, and the older page is usually the one that lags.
Gemini Apps Help lists the conditions for adding your own MCP server to the Gemini app:
Write actions currently need manual confirmation, so the app asks before a tool edits, sends or deletes anything. That is a sensible default for a consumer product, even if it slows down a long chain of steps.
The help page describes adding a server from the web app:
Dynamic Client Registration lets a client register itself with the server's OAuth provider. Without it, you create the client on the provider side first and paste the credentials into Gemini.
Organizations get a separate path. Google Cloud documents connecting a custom MCP server to Gemini Enterprise, and an administrator does the setup, not each employee. Community write-ups of the release notes report that since June 15, 2026 a custom MCP server can authenticate with a Google Cloud service account access token, which suits internal servers that never meet a human sign-in screen.
Google also announced official MCP support for its own services, so some of the servers a team needs may already exist as managed endpoints. Check there before building a custom one.
The best choice depends on where your server runs and who the user is. Use this table as a first filter:
| What you need | Best route | Why |
|---|---|---|
| Local files and shell tools | Gemini CLI | stdio servers run on your own machine |
| A Python or JS backend with custom logic | SDK session | Your code controls the whole loop |
| A hosted agent calling remote endpoints | Managed agents | No proxy layer, still in preview |
| A personal assistant with your own tools | Gemini app | URL only, US English, personal account |
| A company-wide rollout | Gemini Enterprise | Administrators manage connections |
Two patterns come up again and again. Developers prototype in Gemini CLI because the feedback loop is a single command, then move the same server to a remote URL once it works. That move costs almost nothing, since a server written for one MCP client usually behaves the same for another. Teams that start in the app often hit the eligibility wall early, because the US, personal account and English conditions rule out many work setups.
In Gemini CLI, url means SSE and httpUrl means streamable HTTP. A server that speaks streamable HTTP but sits under url will fail to connect, and the error rarely says why. Check which transport your server documents, then match the field. gemini mcp list shows the connection status right away.
Setting trust to true skips the confirmation dialogs, which feels great until a tool does something you did not expect. Start with confirmations on. Use includeTools to expose only the tools a task needs, and widen the list once you have watched the server behave.
The Gemini app takes a URL, not a command. A server on your laptop cannot be reached from there. Deploy it behind HTTPS first, then paste that address under Connected Apps. If the server needs OAuth and has no Dynamic Client Registration, keep the client credentials ready before you start.
MCP projects involve a lot of writing: config blocks, tool descriptions, test prompts and review notes. PicassoIA hosts several Gemini models in its Large Language Models category, including Gemini 3.5 Flash for quick drafts, Gemini 3 Flash for fast chat, and Gemini 3.1 Pro and Gemini 3 Pro for harder reviews. In this workflow PicassoIA is the drafting desk. The MCP connection itself still happens in the Gemini surface you picked above.
settings.json block that uses httpUrl.excludeTools for a read-only session?"/mcp.💡 Specific prompts win. "Write a config for a remote server with a bearer header and one allowed tool" beats "set up MCP" every time.
MCP is not only for text and code. A creative team can connect an image or video generator as a tool, so an assistant produces visuals as part of a longer task, such as drafting a post and generating its header in the same session.
PicassoIA offers a developer API and MCP connections for its image and video models. The API follows an asynchronous pattern: you create a prediction, poll for its status, then fetch the result. As of early October 2026 the limit is 5 concurrent predictions per account, shared across your API tokens and MCP connections. Plan requirements and pricing can change, so check the pricing page before you build on it. Whether a given Gemini surface accepts that connection depends on the rules above: the CLI and SDK can reach it with the right transport, while the Gemini app needs the eligibility conditions to line up.
You do not need an API to start. PicassoIA Image turns a written prompt into a photorealistic picture, and PicassoIA Image Editor Pro refines an existing photo with plain-language edits. For video, browse the full catalog at picassoia.com/en/all-models.
Try it now: open PicassoIA, describe a scene with a lens, a light direction and a mood, and run it. Change one detail, run it again, and compare. Your first strong image is usually two or three prompts away.
