Building a Job-Search MCP Server for Claude: A Complete Guide

What MCP Is and Why It Matters for Job Search

Model Context Protocol (MCP) is Anthropic's open standard for giving AI assistants access to live data and external tools. Instead of relying on training data that may be months or years out of date, an MCP-connected Claude can query real-time sources — databases, APIs, file systems — during a conversation.

For job search, this is transformative. Without MCP, Claude can only give advice based on general knowledge about the job market. With an MCP server connected to live job data, it can answer questions like "which companies in Austin are hiring senior Go engineers right now" or "what skills appear in 70% of ML engineer job descriptions this month" — grounded in data that's hours old, not a year old.

The JobDataLake MCP server provides exactly this: live access to 1M+ job listings through tools that Claude can call naturally during conversation.

Setting Up the MCP Server

You can use the JobDataLake MCP server without an API key (free tier: 500 calls/day by IP) or with your own key for unlimited access.

With Claude Desktop

Add the following to your Claude Desktop configuration file at ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "jdl": {
      "command": "npx",
      "args": ["-y", "@jdl/mcp-server"],
      "env": {
        "JDL_API_KEY": "your_api_key_here"
      }
    }
  }
}

Restart Claude Desktop. You'll see a hammer icon in the message input, confirming the tools are loaded.

Remote MCP (No Local Setup)

The JobDataLake MCP server also runs remotely at https://mcp.jobdatalake.com/mcp. Some Claude integrations support connecting to remote MCP servers directly without local installation:

{
  "mcpServers": {
    "jdl": {
      "type": "http",
      "url": "https://mcp.jobdatalake.com/mcp",
      "headers": {
        "X-API-Key": "your_api_key_here"
      }
    }
  }
}

Available Tools

The MCP server exposes five tools that Claude can use during conversation:

search_jobs

The core search tool. Supports text queries plus structured filters:

• q — keyword query (title, company, skills)
• location — city, country code (US, GB, DE), or continent (Europe, Asia)
• salary_min / salary_max — in thousands (150 = $150k)
• skills — comma-separated, AND semantics (must match all)
• seniority — intern, junior, mid, senior, lead, staff, director, vp
• remote — true/false
• employment_type — full_time, part_time, contract
• date_from — ISO date, filter by posting date
• per_page / page — pagination

get_job

Fetch full details for a specific listing including the complete job description. Takes a job id or handle (the URL slug).

get_company

Fetch a company profile including metadata — description, size, industry, website, and recent job count. Takes a company handle.

find_similar_jobs

Vector similarity search — given a job ID, returns the most similar listings based on semantic content. Useful for finding related roles when a specific listing is a near-miss. Best for remote and tech roles.

get_filter_options

Returns the available values for filter fields — valid seniority levels, employment types, remote types. Useful for Claude to discover what values are supported before filtering.

What Claude Can Do With These Tools

Once connected, Claude reasons about job data naturally as part of conversation. Here are some example exchanges:

Salary Benchmarking

User: What are senior data engineers earning in New York right now?

Claude: [calls search_jobs with title="data engineer", location="New York", seniority="senior", per_page=50]

Based on 47 active listings, senior data engineers in New York are currently being offered $160k–$220k base, with a median range of $175k–$195k. About 30% of listings include equity. The roles requiring Spark and Kafka tend to be at the higher end.

Skill Gap Analysis

User: I'm a mid-level Python developer. What skills should I add to break into machine learning roles?

Claude: [calls search_jobs with title="machine learning engineer", seniority="mid,senior", per_page=100]

Looking at 100 current ML engineer listings, the skills appearing in more than 60% of postings are: Python (97%), PyTorch (68%), AWS or GCP (65%), SQL (62%), and MLflow or similar experiment tracking (61%). You have Python covered. The highest-leverage additions would be PyTorch and one cloud platform — together they appear in the majority of postings.

Company Research

User: What's Anthropic hiring for right now?

Claude: [calls search_jobs with q="anthropic", per_page=20] [calls get_company with handle="anthropic"]

Anthropic currently has 23 open roles. The largest clusters are: research (8 roles — mostly interpretability and alignment), engineering (7 roles — infrastructure and ML systems), and policy/trust & safety (4 roles). The engineering roles are skewing senior — L5+ equivalent based on salary ranges ($250k–$400k total comp).

Building Custom Agents With the MCP Server

The MCP server isn't just for Claude Desktop — it's also usable from any MCP-compatible agent framework. Here's a TypeScript example using the Anthropic SDK:

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

async function jobSearchAgent(userQuery: string) {
  const tools = [
    {
      name: 'search_jobs',
      description: 'Search for job listings with filters',
      input_schema: {
        type: 'object' as const,
        properties: {
          q: { type: 'string', description: 'Search query' },
          location: { type: 'string', description: 'City, country code, or continent' },
          salary_min: { type: 'number', description: 'Min salary in thousands' },
          skills: { type: 'string', description: 'Comma-separated required skills' },
          seniority: { type: 'string', description: 'Seniority level' },
          per_page: { type: 'number', description: 'Results per page (max 50)' },
        }
      }
    }
  ];

  const messages: any[] = [{ role: 'user', content: userQuery }];

  while (true) {
    const response = await client.messages.create({
      model: 'claude-opus-4-7',
      max_tokens: 4096,
      tools,
      messages,
    });

    if (response.stop_reason === 'end_turn') {
      return response.content.find(b => b.type === 'text')?.text;
    }

    if (response.stop_reason === 'tool_use') {
      const toolUse = response.content.find(b => b.type === 'tool_use');
      if (!toolUse || toolUse.type !== 'tool_use') break;

      // Call the JobDataLake API directly
      const params = new URLSearchParams(toolUse.input as Record<string, string>);
      const apiRes = await fetch(`https://api.jobdatalake.com/v1/jobs?${params}`, {
        headers: { 'X-API-Key': process.env.JDL_API_KEY! },
      });
      const jobData = await apiRes.json();

      messages.push(
        { role: 'assistant', content: response.content },
        { role: 'user', content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: JSON.stringify(jobData) }] }
      );
    }
  }
}

Use Cases Beyond Job Search

The same MCP server that powers personal job search enables a range of product applications:

• Career assistants: Personalized job recommendations, skill gap analysis, salary negotiation grounding
• Recruiting tools: Understanding the market for a role before writing a job description, benchmarking compensation
• Market research: Tracking hiring trends in a specific technology or geography over time
• Sales intelligence: Monitoring target accounts for hiring patterns that signal buying intent
• HR analytics: Competitive intelligence on what companies are paying for specific roles

The common thread: any application that benefits from grounding AI reasoning in live, structured job market data. The MCP protocol makes this integration lightweight — a configuration entry and a restart, not a custom API integration.