Skip to main content
Glama
ChanMeng666

Google Jobs MCP Server

by ChanMeng666

A Model Context Protocol (MCP) server implementation that provides Google Jobs search capabilities via SerpAPI integration. Features multi-language support, flexible search parameters, and smart error handling.

Ask DeepWiki

👉Try It Now!👈

https://github.com/user-attachments/assets/8f6739e1-7db7-4171-88b4-59c6290a4c72

屏幕截图 2024-12-31 183813

屏幕截图 2024-12-31 183754

屏幕截图 2024-12-31 180734

屏幕截图 2024-12-31 182106

✨ Features

🌍 Multi-Language Support

Full localization support for English, Chinese, Japanese and Korean with automatic language detection and fallback.

🔍 Flexible Search Options

Comprehensive search parameters including:

  • Job title and keywords

  • Location with radius filtering

  • Employment type (full-time, part-time, etc.)

  • Salary range filters

  • Post date filtering

  • Results sorting

💡 Smart Error Handling

  • Comprehensive input validation

  • Helpful error messages and suggestions

  • Automatic search refinement suggestions

  • Rate limit handling

📊 Rich Job Details

  • Detailed job information formatting

  • Company benefits and highlights

  • Salary information when available

  • Direct application links

  • Job posting timestamps

🔄 Advanced Features

  • Pagination support

  • Multiple sorting options

  • Geographic radius search

  • Employment type filtering

🔑 SERP API Setup Guide

Before getting started, you'll need to obtain a SERP API key:

  1. Visit SERP API website and create an account

  2. After registration, go to your Dashboard:

    • Locate the "API Key" section

    • Copy your API key

    • New users get 100 free API calls

  3. API Usage Details:

    • Free tier: 100 searches per month

    • Paid plans start at $50/month for 5000 searches

    • Billing based on successful API calls

    • Multiple payment methods: Credit Card, PayPal, etc.

  4. Usage Limits:

    • Request Rate: 2 requests/second

    • IP Restrictions: None

    • Concurrent Requests: 5

    • Response Cache Time: 1 hour

👩‍🔧 Solution for MCP Servers Connection Issues with NVM/NPM

Click to view my configuration solution 👉 https://github.com/modelcontextprotocol/servers/issues/76

🚀 Quick Start

  1. Install dependencies:

npm install
  1. Configure environment: Modify your claude_desktop_config.json with the following content (adjust paths according to your system):

{
  "google-jobs": {
    "command": "D:\\Program\\nvm\\node.exe",
    "args": ["D:\\github_repository\\path_to\\dist\\index.js"],
    "env": {
      "SERP_API_KEY": "your-api-key"
    }
  }
}
  1. Build the server:

npm run build
  1. Start the server:

npm start

Troubleshooting

  1. API Key Issues:

  • Verify key in configuration

  • Check key status in SERP API dashboard

  • Confirm key has remaining quota

  1. Search Issues:

  • Validate search parameters format

  • Check network connectivity

  • Verify country/language code support

📦 Installation

Related MCP server: Scrapeless MCP Server

Installing via Smithery

To install Google Jobs for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install @chanmeng666/google-jobs-server --client claude

Manual Installation

@chanmeng666/google-jobs-server

# Using npm
npm i @chanmeng666/google-jobs-server
# or
npm install @chanmeng666/google-jobs-server

# Using yarn
yarn add @chanmeng666/google-jobs-server

# Using pnpm
pnpm add @chanmeng666/google-jobs-server

Running evals

The evals package loads an mcp client that then runs the index.ts file, so there is no need to rebuild between tests. You can load environment variables by prefixing the npx command. Full documentation can be found here.

OPENAI_API_KEY=your-key  npx mcp-eval src/evals/evals.ts src/index.ts

💻 Tech Stack

TypeScript NodeJS MCP

📖 API Documentation

The server implements the Model Context Protocol and exposes a job search tool with the following parameters:

  • query: Search query string (required)

  • location: Job location (optional)

  • posted_age: Post date filter (optional)

  • employment_type: Job type filter (optional)

  • salary: Salary range filter (optional)

  • radius: Geographic search radius (optional)

  • hl: Language code (optional)

  • page: Pagination number (optional)

  • sort_by: Sort order (optional)

🔧 Development

# Run in development mode
npm run dev

# Run type checking
npm run typecheck

# Build for production
npm run build

📝 License

This project is MIT licensed.

🙋‍♀ Author

Created and maintained by Chan Meng. GitHub LinkedIn

AI Assistant Usage Guide

This MCP server is optimized for AI assistant integration. AI assistants can use this tool through the following methods:

Quick Start for AI

  1. Installation: npm install @chanmeng666/google-jobs-server

  2. Configuration: Add server configuration to MCP client

  3. Usage: Call the search_jobs tool for job searching

Search Parameters for AI

  • query: Search keywords (required)

  • location: Job location

  • posted_age: Post date filter (today, 3days, week, month)

  • employment_type: Job type (FULLTIME, PARTTIME, CONTRACTOR, INTERN)

  • salary: Salary range (e.g., $50K+, $100K+)

  • radius: Search radius (e.g., 10mi, 20mi, 50mi)

  • hl: Language code (en, zh-CN, ja, ko)

  • page: Page number (10 results per page)

  • sort_by: Sort order (date, relevance, salary)

AI Use Cases

  • Help users find specific job positions

  • Provide multi-language job search capabilities

  • Filter job opportunities based on criteria

  • Retrieve detailed job information and application links

Error Handling for AI

The system provides intelligent error prompts and search suggestions to help optimize search parameters.

Structured Data for AI Crawlers

AI Crawler Instructions


Available Tools

1 tool
search_jobsB

Google Jobs API search tool.

Supported search parameters:

  1. Basic Search: Job title or keywords

  2. Location: City or region

  3. Time Filter: Recently posted jobs

  4. Job Type: Full-time, part-time, contract, internship

  5. Salary Range: Filter by compensation

  6. Geographic Range: Set search radius

  7. Language: Multi-language support

All parameters except 'query' are optional and can be freely combined.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesSearch keywords (Required, e.g., 'software engineer', 'data analyst', 'product manager')
locationNoJob location (Optional, e.g., 'New York', 'London', 'Tokyo')
posted_ageNoPosting date filter (Optional) Options: - "today": Posted today - "3days": Last 3 days - "week": Last week - "month": Last month
employment_typeNoJob type (Optional) Options: - "FULLTIME": Full-time - "PARTTIME": Part-time - "CONTRACTOR": Contractor - "INTERN": Internship - "TEMPORARY": Temporary
salaryNoSalary range (Optional) Format examples: - "$50K+": Above $50,000 - "$100K+": Above $100,000 - "$150K+": Above $150,000
radiusNoSearch radius (Optional) Format examples: - "10mi": Within 10 miles - "20mi": Within 20 miles - "50mi": Within 50 miles
hlNoResult language (Optional) Options: - "en": English - "zh-CN": Chinese - "ja": Japanese - "ko": Koreanen
pageNoPage number (Optional, default: 1) - 10 results per page - Supports pagination
sort_byNoSort order (Optional) Options: - "date": Sort by date - "relevance": Sort by relevance - "salary": Sort by salaryrelevance

TDQS

B3.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the search parameters and their optionality, which is useful, but it doesn't mention rate limits, authentication requirements, error handling, or what the output looks like (e.g., format, pagination details beyond '10 results per page' in the schema). For a tool with 9 parameters and no annotations, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and front-loaded, starting with the tool's purpose and followed by a structured list of parameters. Every sentence adds value, with no redundant information. However, the bulleted list could be slightly more concise, and the final sentence about optional parameters is necessary but adds length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (9 parameters, no output schema, no annotations), the description is partially complete. It covers the search parameters well but lacks details on behavioral aspects like rate limits, authentication, and output format. Without annotations or an output schema, the description should do more to compensate, but it provides a functional overview that is adequate for basic use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, meaning all parameters are well-documented in the input schema itself. The description adds value by summarizing the supported search parameters in a bulleted list and noting their optionality, but it doesn't provide additional semantic context beyond what the schema already covers (e.g., no examples of combined usage). This meets the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool searches for jobs using the Google Jobs API with specific search parameters. It provides a verb ('search') and resource ('jobs'), making the purpose immediately understandable. However, since there are no sibling tools mentioned, it doesn't need to differentiate from alternatives, so a 5 is not warranted.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage through the list of supported search parameters and notes that all parameters except 'query' are optional. This provides some context for when to use certain features, but it doesn't offer explicit guidance on when to use this tool versus alternatives (none mentioned) or any prerequisites. The guidance is functional but not strategic.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

TDQS

B3.3/5.0
Disambiguation5/5

With only one tool, there is no possibility of ambiguity or overlap between tools. The single tool 'search_jobs' has a clearly defined and distinct purpose for job searching.

Naming Consistency5/5

The tool name 'search_jobs' follows a consistent verb_noun pattern. Since there is only one tool, there is no inconsistency to evaluate, and the naming is straightforward and descriptive.

Tool Count2/5

A single tool is too few for a server named 'Google Jobs MCP Server', which implies a broader domain of job-related operations. While search is a core function, the lack of tools for actions like retrieving job details, applying, or managing saved jobs makes the set feel incomplete and thin.

Completeness2/5

The tool surface is severely incomplete for a jobs domain. It only provides search functionality, missing essential operations such as getting detailed job information, applying to jobs, saving or bookmarking jobs, or filtering by employer. This will likely cause agent failures when trying to perform common job-related tasks beyond basic searching.

Maintenance

ActivityStale
ResponsivenessNo issues

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

Related MCP Servers

  • A
    license
    B
    quality
    D
    maintenance
    A Model Context Protocol server that enables LLMs to perform web searches using Google's Custom Search API through a standardized interface.
    1
    47
    MIT
  • F
    license
    C
    quality
    B
    maintenance
    A Model Context Protocol server that enables LLMs to perform Google searches via the Serper API, allowing models to retrieve current information from the web.
    13
    38
  • A
    license
    Not graded
    quality
    D
    maintenance
    A Model Context Protocol server that enables AI assistants to perform web searches using Google Search API, returning up to 20 search results in JSON format.
    2
    Apache 2.0

Latest Blog Posts

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/ChanMeng666/server-google-jobs'

If you have feedback or need assistance with the MCP directory API, please join our Discord server