Overview

ZIZAI Recruitment’s MCP server implements a Model Context Protocol (MCP) backend tailored for intelligent hiring workflows. It acts as an intermediary between AI models and hiring data — exposing candidate profiles, job postings, and actionable tools as structured resources the model can query or invoke. The server makes it straightforward to combine LLMs with deterministic microservices (screeners, resume parsers, calendar schedulers) to automate candidate matching and recruiter workflows.

For developer teams building hiring assistants, interview schedulers, or sourcing pipelines, the MCP server standardizes how tools and data are presented to models and clients. Instead of hard-coding prompt logic, models request “context” and call tools through the MCP API. This enables reproducible, auditable AI-driven actions (e.g., run a skills score, generate interview questions, or schedule a call) while keeping business logic on the server side.

Features

MCP-compliant API for exposing tools, resources, and contextual data to LLMs
CRUD endpoints for jobs, candidates, and match records
AI-driven matching pipeline hooks (score functions and filters)
Webhook and WebSocket support for real-time events (new match, interview scheduled)
Pluggable tool registry so you can add screeners, parsers, and external integrations
Auth and role-based access (recruiter, admin, candidate) with JWT support
Docker-friendly deployment and standard environment configuration

Installation / Configuration

Prerequisites: Docker & Docker Compose (recommended) or a compatible runtime for building from source.

Clone the repository and start with Docker Compose:

git clone https://github.com/zaiwork/mcp.git
cd mcp
# Start with CI-ready services (Postgres, Redis) and the MCP server
docker-compose up -d

Example docker-compose snippet (for reference):

version: "3.8"
services:
  postgres:
    image: postgres:14
    environment:
      POSTGRES_USER: mcp
      POSTGRES_PASSWORD: mcp_pass
      POSTGRES_DB: mcpdb
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7

  mcp:
    build: .
    environment:
      DATABASE_URL: postgres://mcp:mcp_pass@postgres:5432/mcpdb
      REDIS_URL: redis://redis:6379
      JWT_SECRET: your_jwt_secret
      MCP_HOST: 0.0.0.0
      MCP_PORT: 8080
    ports:
      - "8080:8080"
    depends_on:
      - postgres
      - redis

volumes:
  pgdata:

Environment variables (example .env keys):

DATABASE_URL — Postgres connection string
REDIS_URL — Redis connection string (caching/queues)
JWT_SECRET — Secret used for signing tokens
MCP_HOST / MCP_PORT — Server bind address
LOG_LEVEL — debug|info|warn|error

Run database migrations and start server (examples; your project may use different commands):

# If a Makefile is provided
make migrate
make start

# Or using npm/yarn
npm install
npm run migrate
npm run start

Available Tools / Resources

The server exposes API resources representing hiring entities and callable tools. Common endpoints:

Endpoint	Method	Description
/api/jobs	GET,POST,PUT,DELETE	Manage job postings
/api/candidates	GET,POST,PUT,DELETE	Manage candidate profiles
/api/matches	GET,POST	Create and list match results
/api/tools	GET,POST	Register or list server-side tools accessible via MCP
/mcp/context	POST	Request structured context for an LLM (available tools, relevant data)
/mcp/invoke	POST	Invoke a registered tool (screeners, parsers, schedulers)
/ws/events	WebSocket	Subscribe to real-time events (matches, schedules)

Authentication: API endpoints support JWT bearer tokens. Tool invocations require service-level credentials or scoped tokens.

Tool types:

score: compute a numeric match score
parse: extract structured data (resume parsing)
action: perform side effects (send email, schedule interview) Each tool returns a typed payload so models can incorporate outputs into responses.

Use Cases

Automated candidate matching
- Flow: Recruiter creates a job → MCP computes candidate scores via registered scoring tools → Matches are stored and surfaced in the UI.
- Example create-job payload:
```
{
  "title": "Backend Engineer",
  "skills": ["Go", "Postgres", "Distributed Systems"],
  "location": "Remote",
  "seniority": "mid"
}
```
AI-assisted recruiter assistant
- Flow: An LLM requests context for a candidate and calls tools to generate a shortlist and interview questions. The MCP server supplies the candidate profile and runs a “generate_questions” tool, returning structured results for the UI.
Continuous sourcing pipeline
- Flow: Periodically ingest candidates from third-party sources, parse resumes via a parse tool, then push matches to recruiters via WebSocket notifications when a candidate exceeds a score threshold.

Quick API examples

Create a candidate:

curl -X POST https://localhost:8080/api/candidates \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"Alex Kim","email":"[email protected]","skills":["Python","ML"],"experience":4}'

Request model context (MCP):

curl -X POST https://localhost:8080/mcp/context \
  -H "Authorization: Bearer $SERVICE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"job_id":"job_123","max_tools":5}'

Invoke a tool:

curl -X POST https://localhost:8080/mcp/invoke \
  -H "Authorization: Bearer $SERVICE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tool_id":"resume_parser_v1","input":{"resume_text":"..."} }'

Next steps

Review the repository README and examples to wire up your preferred

ZIZAI Recruitment MCP Server for Intelligent Hiring