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 StartedAny MCP-compatible AI client can connect to SwitchWithAI.
16 tools that cover the entire job application pipeline.
Extract structured JSON from raw resume text or PDF. Gets name, skills, experience, education, and more.
Rewrite any resume to maximize ATS score for a specific job description. Preserves truth, optimizes keywords.
Catch hallucinated skills, inflated metrics, and structural issues before sending. APPROVED / NEEDS_REVIEW / REJECTED.
Get a percentage match between a resume and job description with detailed skill gap analysis.
Aggregate live listings from JSearch, Zenserp, Apify, and SerpApi. Multi-source, real-time results.
Discover recruiters and hiring managers at any company with verified emails via Hunter.io and LinkedIn data.
Generate personalized cold emails to recruiters. 3 paragraphs, human tone, quantified achievements.
Pull required skills, ATS keywords, experience level, and domain from any job description text.
One tool call: parse → extract signals → score → tailor → verify. End-to-end in a single request.
Get verified company info — ratings, employee count, industry, website — via Google Places and LinkedIn data.
AI-generated salary range for any role, company, and location. Min/max LPA with confidence level.
Get likely interview questions, talking points, skills to revise, and a crash preparation guide.
Quick fit assessment — score profile alignment, keyword coverage, and experience match without using a credit.
Parse DOCX resumes directly from base64-encoded files into structured JSON. Same format as PDF parsing.
Up and running in under 2 minutes.
Clone the repo and install dependencies.
git clone https://github.com/risheekmittal/switchwithai-backend.git
cd switchwithai-backend
pip install -r requirements.txt
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
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...
Add the MCP server config to your client (see configuration section below). Make sure to include the SWITCHWITHAI_API_TOKEN env var.
Ask your AI: "Parse my resume and tailor it for this job description"
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..." },
});
Every tool exposed by the SwitchWithAI MCP server.
| Tool | Description | Key Args | Quota |
|---|---|---|---|
| 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).
// 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=...)
// 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 }
}
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: ..." }
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.
Configure API keys and optional integrations.
| Variable | Required | Description |
|---|---|---|
| SWITCHWITHAI_API_TOKEN | Required | Your API key from switchwith.ai (Settings → API Keys), format sw_live_.... Plus or Pro plan required. |
| GOOGLE_API_KEY | Required | Gemini API key for AI-powered parsing and tailoring |
| RAPIDAPI_KEY | Optional | RapidAPI key for live job search (JSearch API) |
| HUNTER_API_KEY | Optional | Hunter.io API key for recruiter email discovery |
| GOOGLE_MAPS_API_KEY | Optional | Google Places API key for company enrichment (enrich_company tool) |
| DATABASE_URL | Optional | PostgreSQL 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.
Combine SwitchWithAI MCP with other tools for powerful workflows.
Search jobs daily → score against your resume → tailor top matches → send to Telegram/Slack via another MCP server.
Find recruiters at dream companies → generate personalized emails → send via Gmail MCP → track responses.
Upload resume once → search 50 jobs → tailor + verify for top 10 → save all versions to Google Drive.
Tailor resume for the same role at different companies → compare scores → pick the highest-scoring version.
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.
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).
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.
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.
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.
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.
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.