# RecruSpace MCP

> RecruSpace manages your entire talent pipeline through API calls, letting your AI client handle HR tasks naturally. Use it to list all candidates (`list_candidates`), update profiles (`update_candidate`), and organize future hires into defined collections using `create_talent_pool`. It gives you granular control over job postings and active applicant data without logging into the platform.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** recruspace, recruitment-api, hr-technology, candidate-management, talent-pools, applicant-tracking, hiring-automation, mcp

## Description

This server lets your AI client manage the entire candidate lifecycle in RecruSpace. You use these tools to handle HR tasks—everything from adding new applicants to tracking interview schedules—without ever having to manually log into the platform. It gives you direct API control over all of your talent data.

**Managing Candidate Records**

To get a full picture of your applicant pool, call `list_candidates` and you'll receive a comprehensive, filterable list of every candidate currently tracked in RecruSpace. If you need deep background on one specific person, use `get_candidate_details` to fetch all their metadata and qualification scores based on the unique ID. When you bring in a new potential hire, call `add_candidate`; this tool requires passing the full profile data as a JSON string so your agent can log them right away. You can modify existing records using `update_candidate`, letting your client change a candidate's status or inject brand-new skills directly into their file.

**Organizing Talent Pools**

You don't want to lose track of great candidates who aren't actively applying yet, right? Use the talent pool tools for that. To start grouping people, call `create_talent_pool`, which builds a brand-new, defined collection within your system and names it after the target group. If you need to see what pools exist already, run `list_talent_pools`. For details on any specific group, use `get_talent_pool` to pull the current list of candidates and their associated metadata from that pool's name.

**Tracking Open Roles and Operations**

Your agent handles all job-related data retrieval. To see an overview of every active or past role you’ve posted, call `list_jobs`. If you need the full details—like salary range or required experience—for just one specific opening, use `get_job` by providing its ID. For operational oversight, your client can check all defined hiring pipelines and their current status across the company using `list_pipelines`. To keep track of people moving through the process, call `list_interviews`; this tool provides a list of every scheduled interview and identifies all associated participants.

**How It Works in Practice**

Your AI client just needs to know which job it's doing. When you need to update someone’s profile or check job statuses, your agent calls the specific function—like `list_interviews` or `update_candidate`. The server runs that command and returns structured data right back to your client. It keeps everything clean, letting you manage complex HR workflows through simple conversation.

## Tools

### add_candidate
Adds a new potential hire record, requiring profile data passed as a JSON string.

### create_talent_pool
Creates a brand-new collection within your system to organize future candidates by name.

### get_candidate_details
Fetches all specific metadata and qualification scores for one candidate ID.

### get_job
Retrieves the full details and status of a single job posting by its ID.

### get_talent_pool
Gets the current list of candidates and metadata for an existing talent pool.

### list_candidates
Returns a comprehensive, filterable list of every candidate currently tracked in RecruSpace.

### list_interviews
Provides a listing of all scheduled interviews and their associated participants.

### list_jobs
Returns an overview list of every active or past job posting in your account.

### list_pipelines
Shows all defined hiring pipelines and their current status across the company.

### list_talent_pools
Lists every talent pool you've created, allowing you to see which groups exist.

### update_candidate
Modifies existing candidate data, such as changing their status or adding new skills.

## Prompt Examples

**Prompt:** 
```
List all active candidates in RecruSpace.
```

**Response:** 
```
I've retrieved your candidates. You have 15 active applicants including 'Alice Miller' and 'Robert Chen'. Would you like to see the qualification score for any of them?
```

**Prompt:** 
```
Show me all active job postings with their application counts and pipeline status.
```

**Response:** 
```
9 active job postings. "Full Stack Developer" leads with 87 applications (12 in screening, 5 interviewing, 2 in final round). "Marketing Manager" has 45 applications (8 screening). "Data Engineer" received 34 applications in 5 days. "Customer Success": 28 applications. 5 additional positions with combined 112 applications. Total active candidates: 306. Average time to first response: 2.3 days. 4 positions have been open for 30+ days and may need refreshed descriptions.
```

**Prompt:** 
```
Add a new candidate to the talent pool for future engineering roles.
```

**Response:** 
```
Candidate added to "Future Engineering Talent" pool. Name: Lisa Wang. Skills: React, TypeScript, Node.js, AWS. Experience: 5 years. Source: Tech Conference referral. The talent pool now has 134 candidates. Lisa has been tagged with "Frontend", "Cloud", and "Mid-Senior". An automated nurture email sequence will begin in 24 hours with company culture content. You'll be notified when matching positions open.
```

## Capabilities

### Manage Candidate Records
Retrieve detailed profiles for specific applicants or list every candidate currently in your system.

### Organize Talent Pools
Create, read, and update collections of candidates (talent pools) to track potential hires outside the active application cycle.

### Monitor Job Postings
Check the status and metadata for any job opening you've posted on RecruSpace.

### Update Candidate Status
Programmatically change a candidate’s information or qualification score using their unique ID.

### Track Interviews and Pipelines
Get lists of scheduled interviews and all active hiring pipelines for operational oversight.

## Use Cases

### The Candidate Status Check
A recruiter needs to know how many people applied last quarter who fit a specific tech stack. Instead of running reports and filtering, they tell their agent: "List all candidates with React skills." The agent runs `list_candidates` and returns an immediate, structured list, saving 15 minutes of manual data crunching.

### Building a Future Pool
The hiring manager meets a great speaker at a conference. They don't need to hire them today but want to track their info for later. They tell the agent: "Add this person's details and put them in 'Future DevOps Talent'." The agent runs `add_candidate` and then `create_talent_pool`, keeping the data clean.

### Auditing Job Post Status
An Ops Manager needs to know which of their 12 open roles are underperforming. They ask the agent: "List all job posts and tell me who's stalled." The agent runs `list_jobs`, provides metadata, and flags any role that hasn't seen activity in two weeks.

### Pipeline Review
A team lead needs to review the overall health of a specific hiring initiative. They ask the agent: "Show me the status of the Senior Product Manager pipeline." The agent runs `list_pipelines` and then checks the associated interviews using `list_interviews`, giving a complete, immediate snapshot.

## Benefits

- Track the full candidate lifecycle. Use `list_candidates` to see every applicant, then use `get_candidate_details` to pull deep qualification metrics without leaving your agent interface.
- Never lose a promising lead again. Build dedicated groups using `create_talent_pool`, and manage those pools later by calling `get_talent_pool`. It’s better than spreadsheets.
- Keep all your job postings in one place. The `list_jobs` tool gives you an immediate overview of every active role, plus its application count and pipeline status.
- Manage candidate data flow directly. If a candidate changes their status or adds skills, run `update_candidate` to keep the record current for everyone who needs it.
- Gain full visibility into operations. Use `list_pipelines` and `list_interviews` together to see exactly where in the process every applicant sits right now.

## How It Works

The bottom line is, your AI agent acts as an API wrapper for RecruSpace, running specific commands based on your intent.

1. Subscribe to the RecruSpace server and provide your API key.
2. Your AI client sends a natural language request (e.g., 'List jobs').
3. The agent selects the appropriate tool (`list_jobs`) and executes it, returning structured data to you.

## Frequently Asked Questions

**How do I list candidates using the RecruSpace MCP Server?**
You use the `list_candidates` tool. This function returns a comprehensive list of all applicants, allowing you to filter and review their current status instantly.

**Can I update candidate info with the RecruSpace MCP Server?**
Yes, you use the `update_candidate` tool. You must provide the specific candidate's ID and the data points you want to change (like skills or status).

**What is the difference between `list_candidates` and `get_candidate_details`?**
`list_candidates` gives you an overview of everyone in your system. `get_candidate_details` requires a specific ID and pulls every single piece of granular data attached to that one person.

**Does the RecruSpace MCP Server let me see all my active job posts?**
Yes, use the `list_jobs` tool. It provides an overview list of your jobs and their current application counts so you know what needs attention.

**Before I run the `list_candidates` tool, how do I connect and authenticate my account?**
You must provide your API key when connecting the server. Once connected, your AI client handles authentication automatically for all subsequent calls. This setup ensures you can immediately use tools like `list_candidates` to pull live data.

**When using `add_candidate`, what kind of structured data do I need to provide?**
The tool requires a JSON string that includes mandatory profile metadata, such as name and core skills. Giving it highly structured input ensures the candidate record is accurate and immediately usable for filtering or matching.

**How does the `create_talent_pool` tool help me organize my hiring process?**
It lets you segment your potential hires into defined groups, based on role or skill set. You pass a name and description to create the pool, keeping candidates organized before they even apply for an open job.

**If I call `get_job` with a specific Job ID, what kind of data will I receive?**
You get granular metadata for that single job posting. This includes the required skills, description text, and status details at the time of retrieval. It won't give you historical applicant counts.

**Can my AI automatically find the details for a specific candidate by providing their ID?**
Yes! Use the `get_candidate_details` tool with the Candidate ID. Your agent will respond with the complete metadata for the profile, including qualifications and status in seconds.

**How do I find my RecruSpace API Key?**
Log in to your RecruSpace account, navigate to the **Settings** or **API** section, and you will find your unique secret API key there.