Google PSE MCP Server
This server enables web searching through Google's Programmable Search Engine API via MCP-compatible clients using a single search tool.
Core functionality:
Perform web searches with customizable query parameters
Paginate results by specifying page number and results per page (1-10 items)
Filter by language using language codes (e.g.,
lang_en,lang_ja)Sort results by date
Enable safe search filtering for content control
Choose API endpoints between standard Google Custom Search or site-restricted options
Integration: Works seamlessly with MCP-compatible applications like VS Code Copilot, Claude Desktop, and other clients for both interactive and programmatic access.
Enables web search capabilities through Google Programmable Search Engine (PSE), allowing users to query the web with customizable parameters like page size, safe search filtering, language restrictions, and site-specific searches.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Google PSE MCP Serversearch for recent breakthroughs in quantum computing"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Google Programmable Search Engine (PSE) MCP Server
A Model Context Protocol (MCP) server for the Google Programmable Search Engine (PSE) API. This server exposes tools for searching the web with Google Custom Search engine, making them accessible to MCP-compatible clients such as VSCode, Copilot, and Claude Desktop.
Installation Steps
You do NOT need to clone this repository manually or run any installation commands yourself. Simply add the configuration below to your respective MCP client—your client will automatically install and launch the server as needed.
VS Code Copilot Configuration
Open Command Palette → Preferences: Open Settings (JSON), then add:
settings.json
{
// Other settings...
"mcp": {
"servers": {
"google-pse-mcp": {
"command": "npx",
"args": [
"-y",
"google-pse-mcp",
"https://www.googleapis.com/customsearch",
"<api_key>",
"<cx>",
"<siteRestricted>" // optional: true/false, defaults to true
]
}
}
}
}Cline MCP Configuration Example
If you are using Cline, add the following to your cline_mcp_settings.json (usually found in your VSCode global storage or Cline config directory):
macOS:
~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.jsonWindows:
%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
{
"mcpServers": {
"google-pse-mcp": {
"disabled": false,
"timeout": 60,
"command": "npx",
"args": [
"-y",
"google-pse-mcp",
"https://www.googleapis.com/customsearch",
"<api_key>",
"<cx>",
"<siteRestricted>" // optional flag, true/false, defaults to true
],
"transportType": "stdio"
}
}
}Important Notes
Don't forget to replace <api_key> and <cx> with your credentials in the configuration above.
You can also provide an optional <siteRestricted> flag (true or false) as the last argument to control which Google Custom Search endpoint is used. If omitted, it defaults to true.
Related MCP server: Scrapeless MCP Server
Available Tools
This MCP server provides the following tool:
search: Search the web with Google Programmable Search EngineParameters:
q(string, required): Search querypage(integer, optional): Page numbersize(integer, optional): Number of search results to return per page (1-10)sort(string, optional): Sort expression (only 'date' is supported)safe(boolean, optional): Enable safe search filteringlr(string, optional): Restrict search to a particular language (e.g., lang_en)siteRestricted(boolean, optional): Use the Site Restricted API endpoint; defaults to true unless overridden via CLI flag
Example Usage
# Search for "artificial intelligence"
result = await use_mcp_tool(
server_name="google-pse-mcp",
tool_name="search",
arguments={
"q": "artificial intelligence",
"size": 5,
"safe": True
}
)Useful Links
Available Tools
1 toolsearchC
Search the Web using Google Custom Search API
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | Search query | |
| page | No | Page number | |
| size | No | Number of search results to return per page. Valid values are integers between 1 and 10, inclusive. | |
| sort | No | Sort expression (e.g., 'date'). Only 'date' is supported by the API. | |
| safe | No | Enable safe search filtering. Default: false. | |
| lr | No | Restricts the search to documents written in a particular language (e.g., lang_en, lang_ja) | |
| siteRestricted | No | If true, use the Site Restricted API endpoint (/v1/siterestrict). If false, use the standard API endpoint (/v1). Default: true. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the API used but fails to describe key behaviors like rate limits, authentication requirements, error handling, or the format of search results. For a web search tool with 7 parameters, this leaves significant gaps in understanding how it operates.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without any wasted words. It's appropriately sized for a tool with this complexity, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no output schema, no annotations), the description is incomplete. It lacks information on result format, error conditions, authentication, and usage constraints, which are critical for an AI agent to use this tool effectively in real-world scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning all parameters are documented in the schema. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 without compensating or detracting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Search') and resource ('the Web'), specifying it uses the Google Custom Search API. It's specific about the action and technology, though without sibling tools to distinguish from, it can't achieve the full differentiation that would warrant a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, prerequisites, or exclusions. It simply states what the tool does without context for usage decisions, which is insufficient for effective tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
With only one tool, there is no possibility of confusion or overlap between tools. The tool's purpose is clearly defined as web search, making it perfectly distinct.
A single tool inherently has perfect naming consistency, as there are no other tools to compare against. The name 'search' is straightforward and follows a simple verb pattern.
A single tool for a Google search server is too minimal for typical agent workflows. While it covers the core function, it lacks related operations like filtering results, handling pagination, or accessing other Google services, making it feel thin and limiting.
The tool set is severely incomplete for a Google search domain. It only provides basic search functionality, missing essential features such as advanced search parameters, result parsing, or integration with other Google APIs (e.g., Maps, Translate), which would be expected in a more comprehensive server.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for Google search results via SERP API
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
A Model Context Protocol server for Wix AI tools
Serper MCP — wraps the Serper Google Search API (serper.dev)
Related MCP Servers
- AlicenseBqualityDmaintenanceA Model Context Protocol server that enables LLMs to perform web searches using Google's Custom Search API through a standardized interface.147MIT
- AlicenseCqualityDmaintenanceA Model Context Protocol server implementation that enables AI assistants like Claude to perform Google searches and retrieve web data directly through natural language requests.1389168MIT
- FlicenseAqualityCmaintenanceA Model Context Protocol server that provides web search capabilities using Google Custom Search API and webpage content extraction functionality.262
- FlicenseNot gradedqualityDmaintenanceA Model Context Protocol server that enables AI applications like Claude Desktop and Cursor IDE to perform web searches via DuckDuckGo's search engine.
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/rendyfebry/google-pse-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server