MODEL CONTEXT PROTOCOL

SwitchWithAI MCP

Give any AI agent the power to parse resumes, search jobs, tailor resumes for specific roles, and verify quality — all through MCP.

Requires a Plus or Pro subscription. Tailor operations use your monthly quota.

Get Started

Works with everything

Any MCP-compatible AI client can connect to SwitchWithAI.

Claude Desktop
Claude Code
Cursor
Windsurf
VS Code Copilot
Cline
Continue
OpenAI Agents SDK
Custom MCP Clients

What you can do

16 tools that cover the entire job application pipeline.

📄

Parse Resumes

Extract structured JSON from raw resume text or PDF. Gets name, skills, experience, education, and more.

🎯

Tailor for Jobs

Rewrite any resume to maximize ATS score for a specific job description. Preserves truth, optimizes keywords.

✅

Verify Quality

Catch hallucinated skills, inflated metrics, and structural issues before sending. APPROVED / NEEDS_REVIEW / REJECTED.

📈

Score Match

Get a percentage match between a resume and job description with detailed skill gap analysis.

🔎

Search Jobs

Aggregate live listings from JSearch, Zenserp, Apify, and SerpApi. Multi-source, real-time results.

🤝

Find Recruiters

Discover recruiters and hiring managers at any company with verified emails via Hunter.io and LinkedIn data.

📧

Write Outreach

Generate personalized cold emails to recruiters. 3 paragraphs, human tone, quantified achievements.

🔧

Extract JD Signals

Pull required skills, ATS keywords, experience level, and domain from any job description text.

🚀

Full Pipeline

One tool call: parse → extract signals → score → tailor → verify. End-to-end in a single request.

🏢

Company Intel

Get verified company info — ratings, employee count, industry, website — via Google Places and LinkedIn data.

💰

Salary Estimate

AI-generated salary range for any role, company, and location. Min/max LPA with confidence level.

🎓

Interview Prep

Get likely interview questions, talking points, skills to revise, and a crash preparation guide.

📋

Job Fit Check

Quick fit assessment — score profile alignment, keyword coverage, and experience match without using a credit.

📄

Parse DOCX

Parse DOCX resumes directly from base64-encoded files into structured JSON. Same format as PDF parsing.

Quickstart

Up and running in under 2 minutes.

Clone and install

Clone the repo and install dependencies.

git clone https://github.com/risheekmittal/switchwithai-backend.git
cd switchwithai-backend
pip install -r requirements.txt

Set your API key

Copy the example env file and add your Gemini API key (required for AI-powered parsing and tailoring).

cp .env.example .env
# Edit .env and set GOOGLE_API_KEY=your-gemini-key

Get your API key

Log in at switchwith.ai with a Plus or Pro plan. Go to Settings → API Keys, generate a key, and set it in your environment:

# Add to your .env or export directly:
SWITCHWITHAI_API_TOKEN=sw_live_a83d9e.4f7c2b1e9d3a5f8c...

Connect to your AI client

Add the MCP server config to your client (see configuration section below). Make sure to include the SWITCHWITHAI_API_TOKEN env var.

Start using it

Ask your AI: "Parse my resume and tailor it for this job description"

Configuration

Connect remotely via HTTP, or run locally with stdio.

Fastest way to start — no clone, no local Python required. Connect any MCP client directly to the hosted server.

// Claude Desktop / Cursor / Windsurf — claude_desktop_config.json or equivalent:
{
  "mcpServers": {
    "switchwithai": {
      "type": "streamable-http",
      "url": "https://api.switchwithai.com/mcp/http/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
# Claude Code — run once:
claude mcp add --transport http switchwithai \
  https://api.switchwithai.com/mcp/http/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"

Get your API key from Settings → API Keys in the SwitchWithAI web app (format: sw_live_...). Requires a Plus or Pro subscription.

SSE transport is also available at https://api.switchwithai.com/mcp/sse/sse for clients that don't yet support streamable-http.

{
  "mcpServers": {
    "switchwithai": {
      "command": "python",
      "args": ["/path/to/switchwithai-backend/mcp_server.py"],
      "env": {
        "GOOGLE_API_KEY": "your-gemini-api-key",
        "SWITCHWITHAI_API_TOKEN": "sw_live_your_key_here"
      }
    }
  }
}

Add this to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows).

# The repo ships with .claude/settings.json pre-configured.
# Set your env vars and start:

export GOOGLE_API_KEY=your-gemini-key
export SWITCHWITHAI_API_TOKEN=sw_live_your_key_here
cd switchwithai-backend
claude

# Or add manually to your project's .claude/settings.json:
{
  "mcpServers": {
    "switchwithai": {
      "command": "python",
      "args": ["mcp_server.py"],
      "env": {
        "GOOGLE_API_KEY": "${GOOGLE_API_KEY}",
        "SWITCHWITHAI_API_TOKEN": "${SWITCHWITHAI_API_TOKEN}"
      }
    }
  }
}
// Add to .cursor/mcp.json in your project root:
{
  "mcpServers": {
    "switchwithai": {
      "command": "python",
      "args": ["/path/to/switchwithai-backend/mcp_server.py"],
      "env": {
        "GOOGLE_API_KEY": "your-gemini-api-key",
        "SWITCHWITHAI_API_TOKEN": "sw_live_your_key_here"
      }
    }
  }
}
// Add to .vscode/mcp.json or VS Code settings:
{
  "mcp": {
    "servers": {
      "switchwithai": {
        "command": "python",
        "args": ["/path/to/switchwithai-backend/mcp_server.py"],
        "env": {
          "GOOGLE_API_KEY": "your-gemini-api-key",
          "SWITCHWITHAI_API_TOKEN": "sw_live_your_key_here"
        }
      }
    }
  }
}
// Add to ~/.windsurf/mcp_config.json:
{
  "mcpServers": {
    "switchwithai": {
      "command": "python",
      "args": ["/path/to/switchwithai-backend/mcp_server.py"],
      "env": {
        "GOOGLE_API_KEY": "your-gemini-api-key",
        "SWITCHWITHAI_API_TOKEN": "sw_live_your_key_here"
      }
    }
  }
}
// Cline MCP Settings → Add Server:
// Name: switchwithai
// Command: python
// Args: /path/to/switchwithai-backend/mcp_server.py
// Env: GOOGLE_API_KEY=your-gemini-api-key
//      SWITCHWITHAI_API_TOKEN=sw_live_your_key_here

// Or add to cline_mcp_settings.json:
{
  "mcpServers": {
    "switchwithai": {
      "command": "python",
      "args": ["/path/to/switchwithai-backend/mcp_server.py"],
      "env": {
        "GOOGLE_API_KEY": "your-gemini-api-key",
        "SWITCHWITHAI_API_TOKEN": "sw_live_your_key_here"
      }
    }
  }
}
# Python — using the MCP SDK
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

server = StdioServerParameters(
    command="python",
    args=["/path/to/switchwithai-backend/mcp_server.py"],
    env={
        "GOOGLE_API_KEY": "your-gemini-api-key",
        "SWITCHWITHAI_API_TOKEN": "sw_live_your_key_here",
    },
)

async with stdio_client(server) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()

        # List available tools
        tools = await session.list_tools()
        print([t.name for t in tools.tools])

        # Call a tool
        result = await session.call_tool(
            "parse_resume",
            arguments={"resume_text": "John Doe, Software Engineer..."},
        )
        print(result)
# TypeScript — using the MCP SDK
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "python",
  args: ["/path/to/switchwithai-backend/mcp_server.py"],
  env: {
    GOOGLE_API_KEY: "your-gemini-api-key",
    SWITCHWITHAI_API_TOKEN: "sw_live_your_key_here",
  },
});

const client = new Client({ name: "my-app", version: "1.0.0" });
await client.connect(transport);

const result = await client.callTool({
  name: "parse_resume",
  arguments: { resume_text: "John Doe, Software Engineer..." },
});

Tool Reference

Every tool exposed by the SwitchWithAI MCP server.

ToolDescriptionKey ArgsQuota
get_plan_and_usage Check your plan, quota, and remaining tailor credits — Free
parse_resume Parse raw resume text into structured JSON resume_text Free
parse_resume_pdf Parse a base64-encoded PDF resume pdf_base64 Free
tailor_resume Tailor resume for a specific job description resume_json, job_description, job_title, company 1 credit
verify_tailored_resume Verify tailored resume for quality and truthfulness original_resume_json, tailored_resume_json Free
score_resume_match Score how well a resume matches a job (0–100%) resume_skills, job_description Free
extract_job_signals Extract skills, keywords, and requirements from a JD job_description Free
search_jobs Search live job listings (multi-source) job_title, location, max_results Free
find_recruiters Find recruiters at a company with email company, role Free
generate_outreach_email Write a personalized recruiter outreach email candidate_name, job_title, company, recruiter_name Free
full_pipeline End-to-end: parse → score → tailor → verify resume_text, job_description 1 credit
parse_resume_docx Parse a base64-encoded DOCX resume docx_base64 Free
enrich_company Get company rating, industry, website, employees company_name Free
estimate_salary AI salary range estimate for a role role, company, location, experience_years, skills Free
generate_interview_prep Interview questions, talking points, crash guide role, company, job_description, skills Free
assess_job_fit Quick fit assessment without tailoring resume_json, job_description Free

Free = requires Plus/Pro plan but no credits consumed. 1 credit = consumes one tailor from your monthly quota (Plus: 100/mo, Pro: 200/mo).

Example: Tailor a resume

// Ask your AI agent:
"I have this resume: [paste resume text]
 Tailor it for this job: [paste job description]
 Then verify the result."

// Behind the scenes, the agent calls:
// 1. parse_resume(resume_text=...)
// 2. tailor_resume(resume_json=..., job_description=...)
// 3. verify_tailored_resume(original=..., tailored=...)

Example: Full pipeline

// One tool call does everything:
full_pipeline(
  resume_text="John Doe\nSoftware Engineer\n5 years Python, React...",
  job_description="We're looking for a Senior Backend Engineer...",
  job_title="Senior Backend Engineer",
  company="Stripe"
)

// Returns:
{
  "parsed_resume": { ... },
  "job_signals": { "required_skills": [...], "ats_keywords": [...] },
  "match_score": { "score": 72, "matched_skills": [...], "missing_skills": [...] },
  "tailored_resume": { ... },
  "verification": { "verdict": "APPROVED", "quality_score": 94 }
}

Error Responses

When something goes wrong, tools return a structured error object:

// Authentication error (missing token, free plan, expired token)
{ "error": true, "code": "AUTH_ERROR", "message": "MCP access requires a Plus or Pro subscription..." }

// Quota exceeded
{ "error": true, "code": "AUTH_ERROR", "message": "Monthly tailor limit reached (100/100). Resets: 2025-08-01..." }

// Validation error (bad input)
{ "error": true, "code": "VALIDATION_ERROR", "message": "resume_json is not valid JSON: ..." }

// Rate limit exceeded
{ "error": true, "code": "AUTH_ERROR", "message": "Rate limit exceeded (10 calls/minute). Try again shortly." }

// Internal error (unexpected failure)
{ "error": true, "code": "INTERNAL_ERROR", "message": "Resume parsing failed: ..." }

Rate Limits

All tools are rate-limited to 10 calls per minute per user on a rolling 60-second window. If you exceed the limit, wait a few seconds and retry. Rate limits are per-user (based on your API key) and do not consume tailor credits.

Environment Variables

Configure API keys and optional integrations.

VariableRequiredDescription
SWITCHWITHAI_API_TOKENRequiredYour API key from switchwith.ai (Settings → API Keys), format sw_live_.... Plus or Pro plan required.
GOOGLE_API_KEYRequiredGemini API key for AI-powered parsing and tailoring
RAPIDAPI_KEYOptionalRapidAPI key for live job search (JSearch API)
HUNTER_API_KEYOptionalHunter.io API key for recruiter email discovery
GOOGLE_MAPS_API_KEYOptionalGoogle Places API key for company enrichment (enrich_company tool)
DATABASE_URLOptionalPostgreSQL URL for persistent storage

SWITCHWITHAI_API_TOKEN and GOOGLE_API_KEY are required. Without the optional keys, job search returns sample data and recruiter search uses pattern-based email guessing.

Automation Ideas

Combine SwitchWithAI MCP with other tools for powerful workflows.

Job Alert Pipeline

Search jobs daily → score against your resume → tailor top matches → send to Telegram/Slack via another MCP server.

Recruiter Outreach

Find recruiters at dream companies → generate personalized emails → send via Gmail MCP → track responses.

Batch Application

Upload resume once → search 50 jobs → tailor + verify for top 10 → save all versions to Google Drive.

Resume A/B Testing

Tailor resume for the same role at different companies → compare scores → pick the highest-scoring version.

FAQ

What is MCP?

Model Context Protocol (MCP) is an open standard created by Anthropic that lets AI models connect to external tools and data sources. Think of it like USB-C for AI — one protocol, works everywhere.

Does this cost money?

The MCP server requires a Plus (100 tailors/mo) or Pro (200 tailors/mo) subscription at switchwith.ai. Free-plan users cannot access the MCP. Tailor operations consume credits from the same monthly quota as the web app. You also need a Gemini API key (free tier available at ai.google.dev).

What happens when I run out of credits?

Read-only tools (parse, score, search, verify) keep working — only tailor_resume and full_pipeline consume credits. When your quota is exhausted, those tools return a clear error with your usage and reset date. You can buy extra credits or wait for the monthly reset.

Is my resume data sent anywhere?

Your resume is processed locally by the MCP server and sent to Google Gemini for AI processing. No data is stored permanently unless you configure a database. The MCP server runs on your machine.

Can I use this with ChatGPT / GPT-4?

Yes! Any AI client that supports MCP can use this server. OpenAI's Agents SDK supports MCP natively. For ChatGPT Desktop, check if MCP support has been added to your version.

How do I add more tools?

Open mcp_server.py and add a new function decorated with @mcp.tool(). The tool's docstring becomes the description, and type hints become the schema. Restart the server and your AI client will see the new tool.

Can I run this as a remote server?

Yes — it already is! The hosted server at api.switchwithai.com exposes both streamable-http (/mcp/http/mcp) and SSE (/mcp/sse/sse) transports. See the Remote (HTTP) tab in the Configuration section above. No local setup required.