HomeDocsCareerBoard for Grok

AI assistant

CareerBoard for Grok

Use the connector guide in CareerBoard Settings to bring the live workspace into Grok. The setup is manual today, but it is already easy to follow and much more powerful than another stateless prompt thread.

Overview

Why Grok is worth connecting

CareerBoard is not listed in connector stores yet. The right story today is simple manual setup with a clear guide inside Settings.

What changes

Grok gets the real CareerBoard workspace behind the conversation instead of pasted snippets.

Projects, applications, candidate context, generated documents, and interview work stay tied to the same role trail.

Users can turn Grok into a practical job-search copilot without moving the workflow out of CareerBoard.

Why setup feels easy

The Grok guide is already present inside CareerBoard Settings.

Users get screenshots plus copy-ready server and OAuth values.

The manual flow is short: create, paste, connect, authorize, test.

Best when

The user wants Grok to operate on active applications, not generic listing searches.

Role evaluation, tailoring, and prep should stay grounded in stored workspace context.

The conversation should keep the same board and document trail instead of resetting each time.

Setup

Open Settings and follow the screenshot guide

Everything starts from CareerBoard Settings. Pick Grok, follow the illustrated steps, paste the provided values into your client, and authorize once.

Manual for now. Fast in practice.

The Settings screen includes a convenient provider-specific instruction flow with screenshots, so users do not have to guess where each field belongs.

Open CareerBoard Settings and choose Grok

Start from the Connectors tab and use the screenshot-based Grok guide inside CareerBoard.

Create a custom connector in Grok

Follow the guide to open Grok's connector screen and create a new custom connector for CareerBoard.

Paste the provided server and OAuth details

CareerBoard provides the exact values Grok expects, including the MCP endpoint and OAuth credentials.

Authorize and test in chat

Save, connect, approve access through CareerBoard, and try a short first prompt to confirm the setup.

Prompts

What to ask Grok right after setup

The first tests can stay simple. The main win is that the assistant now works from your real workspace instead of a blank conversation.

Show my CareerBoard projects.

Summarize my main application board and tell me which roles need follow-up first.

Evaluate whether this vacancy is worth pursuing for my current project.

Generate a tailored resume for this board item.

Draft a cover letter for this application and keep it tied to the role.

Prepare me for the next interview using the resume already attached to this application.

Value

What opens up after connection

The setup is manual, but the payoff is a much better operating layer for the active search.

See the real project board

The model can summarize active roles, stalled applications, and next actions from the workspace instead of from a pasted list.

Keep artifacts tied to the role

Resumes, cover letters, prep notes, and reviews stay linked to the application instead of drifting across separate chats.

Generate with better context

Vacancy evaluation, tailoring, and interview work can start from the same stored candidate and project context every time.

Turn chat into an operating layer

The assistant becomes more useful when it can act on the live search system instead of responding to one isolated prompt.

Methods

Current CareerBoard MCP methods

This is the current tool surface available to supported clients connected through CareerBoard.

Workspace and profile

Use these methods to inspect the authenticated user's projects and the reusable candidate context behind each project.

List Projects

list_projects

Read

Load the user's current CareerBoard projects.

Inputs: none
Returns: Project summaries with names, locations, archive state, and timestamps.

Show Project Board

show_project_board

Read

Load one project board grouped by application stage.

Inputs: projectId
Returns: Board columns for todo, applied, active, declined, and archived items.

Get Project Candidate Profile

get_project_candidate_profile

Read

Read the project-level candidate profile and summary fields.

Inputs: projectId
Returns: Candidate profile markdown, summary state, and related metadata.

Update Project Candidate Profile

update_project_candidate_profile

Write

Replace the main candidate profile markdown for a project.

Inputs: projectId, contentMarkdown
Returns: The updated candidate profile record.

Applications and artifacts

These methods cover application detail, artifact lookup, comments, and board movement inside an active job-search project.

Get Application

get_application

Read

Load one board item with vacancy text, comments, interviews, and status history.

Inputs: itemId
Returns: Full application detail plus linked artifacts, comments, and interview records.

Create Application

create_application

Write

Create a new board item for a role.

Inputs: projectId, companyName, title, vacancyUrl?, vacancyText?, status?
Returns: The new progress-board item.

Move Application

move_application

Write

Move an existing application to another stage and position.

Inputs: itemId, status, position
Returns: The updated progress-board item.

Get Application Resume

get_application_resume

Read

Load the tailored resume attached to an application.

Inputs: itemId
Returns: Resume state, related artifacts, and PDF metadata when available.

Get Application Cover Letter

get_application_cover_letter

Read

Load the cover letter attached to an application.

Inputs: itemId
Returns: Cover letter state, related artifacts, and PDF metadata when available.

Get Application Interview Preparation

get_application_interview_preparation

Read

Load the current interview-preparation artifact for an application.

Inputs: itemId
Returns: Interview-preparation state and related role context.

List Application Comments

list_application_comments

Read

List comments attached to one application.

Inputs: itemId
Returns: Comment bodies, authors, attachments, and timestamps.

Add Application Comment

add_application_comment

Write

Create a new comment on a board item.

Inputs: itemId, body?
Returns: The newly created comment.

Interview workflow

Use these methods to inspect scheduled interviews, manage interview records, and work with transcript and overview state.

Get Project Interview Schedule

get_project_interview_schedule

Read

List interviews scheduled in a project.

Inputs: projectId, from?, to?
Returns: Interview entries with company, title, recruiter, time, and status fields.

Get Interview Overview

get_interview_overview

Read

Load interview transcript and overview state for one interview.

Inputs: interviewId
Returns: Interview context, transcription state, and generated overview content.

Create Application Interview

create_application_interview

Write

Create a new scheduled interview under one application.

Inputs: itemId, recruiterName, scheduledAt, meetingUrl?
Returns: The created interview plus the updated application summary.

Update Application Interview

update_application_interview

Write

Update one existing interview attached to an application.

Inputs: interviewId, recruiterName?, scheduledAt?, meetingUrl?
Returns: The updated interview record.

Delete Application Interview

delete_application_interview

Write

Delete one interview attached to an application.

Inputs: interviewId
Returns: A deletion confirmation with the removed interview id.

Prepare Interview

prepare_interview

Async

Enqueue interview-preparation generation for an application.

Inputs: itemId, currentContentJson?
Returns: A background task object.
Note: Usually completes in about 1-3 minutes. Check `get_task_status` if needed.

Scraper setup and sourcing

These methods let the client inspect available scrapers, create source configurations, and manage ongoing scrape inputs for a project.

List Scraper Catalog

list_scraper_catalog

Read

List available vacancy scrapers for the current authenticated billing tier.

Inputs: none
Returns: Supported scraper catalog entries with site and capability metadata.

List Scrape Sources

list_scrape_sources

Read

List configured vacancy scrape sources for a project.

Inputs: projectId
Returns: Source records with names, enablement, and status fields.

Create Scrape Source

create_scrape_source

Write

Create a new vacancy scraping source for a project.

Inputs: projectId, scraperId, name, urls[], resultLimit, isEnabled?, recurrenceEnabled?, evaluateEnabled?
Returns: The created scrape source record.

Generate Scrape Sources

generate_scrape_sources

Async

Generate suggested search URLs for new vacancy scraping sources in a project.

Inputs: projectId, wish?
Returns: Suggested search URLs grouped by scraper and search intent.

Update Scrape Source

update_scrape_source

Write

Update one existing vacancy scrape source.

Inputs: sourceId, scraperId?, name?, urls[]?, resultLimit?, isEnabled?, recurrenceEnabled?, evaluateEnabled?, status?
Returns: The updated scrape source record.

Delete Scrape Source

delete_scrape_source

Write

Delete one vacancy scrape source and its owned scraping data.

Inputs: sourceId
Returns: A deletion confirmation for the scrape source.

Scrape runs and vacancy review

These methods let the client run scrapers, inspect scraped vacancy inboxes, review results, and import promising roles into the board.

Run Scrape Source

run_scrape_source

Async

Reserve funds and enqueue one run for a single vacancy scrape source.

Inputs: sourceId
Returns: A scrape run envelope for the queued source run.

Run All Scrape Sources

run_all_scrape_sources

Async

Enqueue one scrape run across all enabled sources in a project.

Inputs: projectId
Returns: A scrape run envelope for the project-wide run.

Create Scrape Run

create_scrape_run

Async

Create an ad hoc vacancy scraping run for one project and URL.

Inputs: projectId, scraperId, url, resultLimit, evaluateEnabled?
Returns: A scrape run envelope for the ad hoc run.

List Scrape Runs

list_scrape_runs

Read

List vacancy scraping runs for a project.

Inputs: projectId
Returns: Run records with origin, status, counts, and timestamps.

Cancel Scrape Run

cancel_scrape_run

Write

Cancel one queued vacancy scraping run.

Inputs: runId
Returns: The canceled run id and final status.

Retry Scrape Run

retry_scrape_run

Async

Retry one failed or canceled vacancy scraping run from its saved snapshot.

Inputs: runId
Returns: A fresh scrape run envelope created from the earlier run.

List Scraped Vacancies

list_scraped_vacancies

Read

Load scraped vacancies with optional review, source, run, verdict, and search filters.

Inputs: projectId, mode?, sourceIds[]?, scraperIds[]?, runIds[]?, withDescription?, verdicts[]?, onlyNewInSelectedRuns?, onlyEvaluated?, onlyNotEvaluated?, boardImportState?, search?, sortBy?, sortDirection?
Returns: Vacancy list, review-state summary, and project-level counts.

Mark Scraped Vacancies Reviewed

mark_scraped_vacancies_reviewed

Write

Mark the current scraped vacancy inbox as reviewed for one project.

Inputs: projectId
Returns: The updated project review state.

Get Scraped Vacancy Detail

get_scraped_vacancy_detail

Read

Load one full scraped vacancy detail, including description text and AI rationale.

Inputs: projectId, vacancyId
Returns: Detailed vacancy content, extracted fields, and evaluation rationale when available.

Evaluate Scraped Vacancies

evaluate_scraped_vacancies

Async

Queue AI evaluation for selected scraped vacancies.

Inputs: projectId, scrapedVacancyIds[]
Returns: Queued, skipped, and requested vacancy counts.

Extract Manual Vacancy

extract_manual_vacancy

Async

Enqueue extraction of normalized vacancy fields from externally supplied readable page text.

Inputs: projectId, pageReadableText
Returns: A background task object.

Evaluate Manual Vacancy

evaluate_manual_vacancy

Async

Queue AI evaluation for one manually supplied vacancy description against the project profile.

Inputs: projectId, vacancyTitle, companyName, vacancyDescriptionText
Returns: A background task object.

Import Scraped Vacancies To Board

import_scraped_vacancies_to_board

Write

Import selected scraped vacancies into the project board.

Inputs: projectId, scrapedVacancyIds[]
Returns: Imported board items and whether each one was newly created or already existed.

Generation and billing

This part of the tool surface handles long-running document generation, task polling, and usage visibility.

Generate Resume

generate_resume

Async

Queue tailored resume generation for an application.

Inputs: itemId, wishText?, currentContentJson?
Returns: A background task object.
Note: Usually completes in about 1-3 minutes. Check `get_task_status` if needed.

Generate Cover Letter

generate_cover_letter

Async

Queue tailored cover-letter generation for an application.

Inputs: itemId, wishText?, currentContentJson?
Returns: A background task object.
Note: Usually completes in about 1-3 minutes. Check `get_task_status` if needed.

Get Task Status

get_task_status

Read

Load one background task by id.

Inputs: taskId
Returns: Task status, attempts, timestamps, result, and error state.

Get Billing Overview

get_billing_overview

Read

Return the current billing tier and available balance for the user.

Inputs: none
Returns: Tier details, balance values, and operation reservation hints.

Notes

Simple setup, real workspace value

A few notes for using CareerBoard as the workspace behind Grok.

Good to know

CareerBoard is not in the Grok connector store yet, so setup is manual for now through the guide in Settings.

The Settings flow includes screenshots plus copy-ready MCP and OAuth values.

The strongest Grok use cases are application tracking, vacancy evaluation, tailoring, interview prep, and review.

Privacy

CareerBoard only exposes data available to the connected account, and the setup guide is shown inside the product settings where users also manage access.

Read the privacy policy