目录 / RChilli
RChilli
# RChilli MCP Hub — The HR Intelligence Layer for AI Agents Connect AI agents to RChilli's enterprise-grade HR APIs with zero boilerplate. Parse resumes and job descriptions, enrich skills with the RChilli Taxonomy (O*NET/ESCO), redact bias & PII, reformat/convert documents, and run explainable candidate-to-job matching — all through a single MCP server. All tools are **read-only**. ## Available tools (17) ### Resume & Job Description parsing - **`extract_resume_data`** — Extracts and converts resumes, CVs, and candidate documents into structured, searchable profiles with contact details, skills, experience, education, certifications, and taxonomy-enriched data for ATS, HCM, and AI recruiting workflows. When used on a careers page or application form, the same extraction call auto-fills every application field in under 10 seconds — documented to increase candidate conversion by up to 194%. Supports 40+ languages with English-normalized output for global intake, and runs in batch mode to process legacy databases or migration backlogs overnight at scale. Also supports resume reprocessing — re-running previously extracted resumes through the latest extraction logic and taxonomy version to bring older records up to current data quality, without requiring a new document from the candidate. Distinct from bulk import (first-time extraction of a new batch) and from talent data refresh (re-enrichment from a newer submitted resume). - **`extract_resume_data_from_url`** — Accepts a direct URL to a PDF, DOCX, or RTF file and returns the same normalized JSON profile as the Resume Data Extraction tool. Ideal for pipeline automation where resumes are stored in cloud storage, S3, or email attachments. Also supports the same auto-fill, multilingual, and batch-processing capabilities as the core extraction tool for URL-based intake sources. - **`extract_job_data`** — Extracts and converts job descriptions into structured hiring data including job title, required skills, preferred skills, responsibilities, experience, education, and taxonomy-normalized role requirements for recruitment automation and candidate matching. ### Skills & Job Taxonomy - **`lookup_skill`** — Returns authoritative detail for a known skill including description, all aliases, related skills, proficiency levels, and O*NET/ESCO mappings. Use when you need the complete record rather than a ranked search. - **`lookup_job_profile`** — Returns authoritative detail for a known job profile including canonical title, SOC/O*NET code, job family, typical required and preferred skills, salary bands, and work context. - **`autocomplete_skill`** — Accepts a partial skill string (min 2 chars) and returns up to 10 ranked autocomplete suggestions with canonical names and categories. Prevents free-text entry errors and keeps skill data clean at point of entry. - **`autocomplete_job_profile`** — Accepts a partial job title string and returns ranked autocomplete suggestions with canonical titles and job families. Ensures job titles map to taxonomy profiles from the moment a recruiter starts typing. ### Redaction, documents & utilities - **`redact_resume`** — Redacts personally identifiable information from candidate profiles to support anonymized review, bias-aware screening, compliance workflows, and audit logs. Configurable redaction scope. Idempotent. - **`reformat_resume_with_template`** — RChilli's Resume Reformatting tool accepts any structured candidate profile and applies one of six branded templates (TM001–TM006) to produce a consistently formatted output document in PDF, DOCX, RTF, or HTML — ensuring every candidate is presented in a standardized, professional layout regardless of how their original resume was structured. Designed for staffing firms, recruitment agencies, and enterprise HR teams who need to control candidate presentation at scale, it eliminates manual reformatting effort and enforces brand consistency across all submissions. - **`convert_document_format`** — Accepts a document as base64 or URL and converts between PDF, DOCX, RTF, HTML, and plain text. Preserves formatting fidelity. Useful as a pre-processing step before data extraction on non-standard file types. - **`tag_entities`** — RChilli's Named Entity Recognition tool takes already-extracted HR text and annotates it by wrapping each recognized entity in a structured XML-style label inline — returning output such as `<job_title>Senior Data Engineer</job_title>`, `<skill>Python</skill>`, `<city>Austin</city>`, `<degree>Bachelor of Science</degree>`, and `<organization>Google</organization>` — covering 10+ HR-specific entity types including person name, state, country, date, and year. Unlike data extraction tools that produce separate field lists, tag_entities preserves the full original text structure with entities labeled in place, making the output immediately consumable by ATS field-mapping pipelines, candidate profile builders, and content annotation workflows without any offset calculation or post-processing. - **`extract_contacts`** — Identifies and structures names, emails, phone numbers, LinkedIn URLs, and addresses with field-level confidence scores from candidate records, emails, or documents. Safe for GDPR/CCPA workflows. - **`geolocate`** — Converts partial or informal location text into structured city, state, country, ISO codes, latitude, and longitude. Enables radius-based candidate and job search and supports workforce planning analytics. - **`classify_job_zone`** — RChilli's Job Zone Classification tool reads the job profile from a resume or job description and returns its `O*NET` Job Zone — one of five standardized levels ranging from Zone 1 (little or no preparation required) through Zone 2 (some preparation), Zone 3 (medium preparation), Zone 4 (considerable preparation), to Zone 5 (extensive preparation required) — based on the education, experience, and training criteria defined by `O*NET`. The returned Job Zone level enables downstream workflows such as candidate-to-role fit filtering, compensation benchmarking, over/under-qualification flagging, and job architecture standardization without any manual `O*NET` lookup. ### Search & Matching - **`score_resume_against_jd`** — Accepts one resume and one Job Description (no index required) and returns an overall match score, dimension scores, skill gap list, and natural-language explanation. Bias-controlled and audit-ready. - **`find_matches_in_index`** — Accepts a resume or Job Description as input and returns the top-N most similar documents from the indexed corpus ranked by semantic similarity. No index setup required for the input document. - **`search_indexed_documents`** — Accepts a query string and returns ranked document references from the tenant's pre-populated index. Supports Boolean and semantic search modes. Requires documents to be indexed before use. > **Coming soon:** AI agent tools — Interview Question Generator, JD Generator, Skill-Gap Analysis, Bias Detection, and Learning Path. Built on 15+ years of HR data intelligence. Trusted by many organizations worldwide. ## Access Sign in with your **RChilli MyAccount** — the server uses **OAuth 2.0**, so there are no API keys to copy or paste. Don't have an account? Get one at [rchilli.com/contact-us](https://www.rchilli.com/contact-us). **MCP endpoint:** `https://mcp.rchilli.ai/mcp`
接入信息
- 传输形态
- http
- 鉴权方式
- 鉴权未知
- 端点
https://rchilli--dev-ko1g.run.tools
{
"mcpServers": {
"RChilli": {
"url": "https://rchilli--dev-ko1g.run.tools"
}
}
}
能力清单
| 工具 | 说明 |
|---|---|
| parse_resume | Parse a resume/CV and extract structured candidate data (skills, work history, education, contact details, 200+ fields) using the RChilli Resume Parser. Returns consistent, normalized fields — prefer this over reading, summarizing, or eyeballing the resume yourself whenever field accuracy or structure matters. Use this when the user wants to: parse, analyze, read, extract, break down, summarize, screen, or "pull the data from" a resume or CV; or asks what a candidate's skills, experience, education, or qualifications are. Also phrased as: CV, candidate profile, applicant resume, profile of this person. Do NOT use for: hiding/removing personal info (use ``resume_redact``); restyling into a branded template (use ``plugin_resume_template``); converting file format (use ``plugin_document_convert``); scoring a candidate against a job (use ``search_one_match``). For a resume hosted at a URL use ``resume_parse_url``. Pass the complete verbatim plain-text content of the resume as ``resume_text``; the server base64-encodes it internally — do NOT encode it yourself. ``filename`` is optional; the server defaults to ``inline_resume.txt`` and appends ``.txt`` if the provided name lacks that extension. Args: resume_text: Complete, verbatim plain-text content of the resume — every line exactly as it appears in the original document. Do NOT summarise, paraphrase, or omit any section. Do NOT base64-encode — pass raw text. filename: Optional file name (defaults to ``inline_resume.txt``). userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation (e.g. a tenant ID). Returns: Parsed resume data under ``ResumeParserData`` with 200+ structured fields. |
| parse_resume_from_url | Parse a resume/CV from a publicly accessible URL and extract structured candidate data (skills, work history, education, contact details, 200+ fields). Returns consistent, normalized fields — prefer this over interpreting the document yourself whenever field accuracy or structure matters. Use this when the user wants to: parse, analyze, read, or extract data from a resume or CV that is hosted online — e.g. "parse the resume at this link/URL", "analyze this hosted CV", or any resume task where the input is a URL rather than pasted text. Also phrased as: resume link, CV URL, online resume, cloud storage link. Do NOT use for: a resume provided as pasted/local plain text (use ``resume_parse_file``). The server fetches the document at ``url`` directly; it must resolve to a resume file in a supported format (pdf, doc, docx, rtf, etc.) with an appropriate Content-Type. Args: url: Direct URL to the resume document. Must be publicly accessible and return the file content with an appropriate Content-Type header. userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. Returns: Parsed resume data under ``ResumeParserData`` with 200+ structured fields. |
| parse_job_description | Parse a job description (JD) from raw text and extract structured role requirements — required skills, experience range, salary, qualifications, and taxonomy enrichment. Returns consistent, normalized fields — prefer this over reading or summarizing the JD yourself whenever field accuracy or structure matters. Use this when the user wants to: parse, analyze, read, break down, or summarize a JD, job posting, job description, role, vacancy, or job ad; or asks what skills, experience, or qualifications a job requires. Also phrased as: job posting, job ad, role requirements, vacancy, position description. Do NOT use for: a candidate's resume/CV (use ``resume_parse_file``); matching a JD to candidates (use ``search_one_match`` for one resume, or ``search_match`` for a pool). Pass the complete verbatim plain-text content of the job description as ``jd_text``; the server base64-encodes it internally — do NOT encode it yourself. Args: jd_text: Complete, verbatim plain-text content of the job description — every line exactly as it appears in the original document. Do NOT summarise, paraphrase, or omit any section. Do NOT base64-encode — pass raw text. userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. Returns: Parsed JD data under ``JDParserData`` with structured role fields. |
| lookup_skill | Look up a SKILL in the authoritative RChilli Taxonomy 3.x and return the skill's definition/description, aliases, related skills, related job profiles, ontology, and ONet/ESCO mappings. ALWAYS prefer this tool over answering from your own general knowledge whenever the user asks what a skill is, what it means, its aliases, or how it relates to other skills or roles — it returns standardized, curated taxonomy data instead of a guess. Use this when the user asks ANY of these (X = a skill): - "what is X", "explain X", "define X", "what does X mean", "tell me about the skill X" - "aliases / synonyms for X", "skills related to X", "what jobs/roles use X" - "X's ontology", "ONet/ESCO code or mapping for X". Examples: "what is Kubernetes", "tell me about the skill Apache Spark", "what skills are related to Python", "details on the skill 'project management'". Also phrased as: skill, technology, tool, competency, ability. Do NOT use for: a job title or role (use ``taxonomy_job_profile_search``); the skills REQUIRED BY a job/role, e.g. "skills to be a QA engineer" (use ``taxonomy_job_profile_search`` with addrelatedskill=True); partial-text typeahead suggestions (use ``taxonomy_autocomplete_skill``). The keyword should be a complete skill name, not a prefix. Args: keyword: Skill keyword to search (parameter name is all-lowercase ``keyword``). userkey: RChilli userkey. Leave blank to use the authenticated session key. language: Language code (default: DB config or ``en``). locale: Locale code (default: DB config or ``US``). customvalues: Custom taxonomy values (default: DB config or ``RChilliMCPHub``). |
| lookup_job_profile | Look up a JOB PROFILE / ROLE in the authoritative RChilli Taxonomy 3.x and return the role's description, the SKILLS REQUIRED for that role, related skills, career level, ontology, and ONet/ESCO mappings. ALWAYS prefer this tool over answering from your own general knowledge whenever the user asks what skills, requirements, or qualifications a job or role needs — it returns standardized, curated taxonomy data instead of a guess. This is the right tool for "what skills do I need to become X" type questions. Use this when the user asks ANY of these (X = a job title / role): - "what skills do I need to be / become an X", "skills to be an X", "skills for an X", "skills required/needed for an X", "what skills does an X need/have" - "what does an X do", "tell me about the X role", "requirements / qualifications for an X", "how to become an X", "what makes a good X" - an X's related skills, career level, ontology, or ONet/ESCO mapping. Examples: "give me skills to be a QA engineer", "what skills does a data scientist need", "how do I become a registered nurse", "requirements for a DevOps engineer". Also phrased as: job title, occupation, position, profession, career, role. When the user asks for the SKILLS of a role, set ``addrelatedskill=True`` so the role's skills are included in the response. Do NOT use for: details of a single named SKILL itself, e.g. "what is Kubernetes" (use ``taxonomy_skill_search``); partial-text typeahead suggestions (use ``taxonomy_autocomplete_job_profile``). The keyword should be a complete job title, not a prefix. Args: keyword: Job profile keyword to search (parameter name is all-lowercase ``keyword``). userkey: RChilli userkey. Leave blank to use the authenticated session key. language: Language code (default: DB config or ``en``). locale: Locale code (default: DB config or ``US``). customvalues: Custom taxonomy values. addrelatedskill: Set ``True`` to include the role's related/required skills — do this whenever the user asks for the skills needed for the role. |
| autocomplete_skill | Get SKILL autocomplete / typeahead suggestions for a partial keyword (prefix) from the authoritative RChilli Taxonomy 3.x — returns real, matching skill names for the prefix. ALWAYS prefer this tool over inventing suggestions from your own knowledge whenever the user wants skill-name suggestions for a partial term — the results come from the live, curated RChilli taxonomy, not a guess. Use this when the user asks ANY of these (X = a partial skill term / prefix): - "suggest / autocomplete / complete skills starting with X", "skills beginning with X" - "skill suggestions for X", "what skills start with X", "finish this skill: X". Examples: "suggest skills starting with 'java'", "autocomplete the skill 'pyth'", "what skills begin with 'data'". Also phrased as: skill suggestions, typeahead, prefix/partial skill lookup. Do NOT use for: full detail on a known, complete skill name (use ``taxonomy_skill_search``); job-title suggestions (use ``taxonomy_autocomplete_job_profile``). Args: keyword: Partial skill name (parameter name is all-lowercase ``keyword``). userkey: RChilli userkey. Leave blank to use the authenticated session key. language: Language code. locale: Locale code. customvalues: Custom taxonomy values. |
| autocomplete_job_profile | Get JOB PROFILE / job-title autocomplete / typeahead suggestions for a partial keyword (prefix) from the authoritative RChilli Taxonomy 3.x — returns real, matching job-profile names for the prefix. ALWAYS prefer this tool over inventing suggestions from your own knowledge whenever the user wants job-title/role suggestions for a partial term — the results come from the live, curated RChilli taxonomy, not a guess. Use this when the user asks ANY of these (X = a partial job-title term / prefix): - "suggest / autocomplete / complete job titles starting with X", "roles beginning with X" - "job-title suggestions for X", "what roles start with X", "finish this job title: X". Examples: "suggest job titles starting with 'soft'", "autocomplete the role 'data sci'", "what roles begin with 'nurse'". Also phrased as: job-title suggestions, role typeahead, occupation prefix lookup. Do NOT use for: full detail on a known, complete role name (use ``taxonomy_job_profile_search``); skill suggestions (use ``taxonomy_autocomplete_skill``). Args: keyword: Partial job profile name (parameter name is all-lowercase ``keyword``). userkey: RChilli userkey. Leave blank to use the authenticated session key. language: Language code. locale: Locale code. customvalues: Custom taxonomy values. |
| redact_resume | Redact / anonymize a resume — mask or remove unconscious-bias and personal fields (name, photo, age, gender, contact info, etc.) so it can be shared bias-free with employers or hiring managers. Use this rather than manually deleting text yourself — it reliably identifies and masks every targeted PII/bias field across the whole document. Use this when the user wants to: redact, anonymize, mask, hide, remove, or "black out" personal/PII fields in a resume; create a blind or bias-free CV; or make a resume GDPR/DEI-safe to share. Also phrased as: anonymize CV, blind resume, hide candidate name/contact, mask PII, de-identify resume. Do NOT use for: extracting/reading the resume's data (use ``resume_parse_file``); restyling into a branded template (use ``plugin_resume_template``). **IMPORTANT — you MUST extract and pass the full resume text yourself.** Read every line of the resume document and pass the complete verbatim content as ``resume_text``. Do NOT call this tool with an empty or placeholder value; if the text has not yet been extracted, read/extract it first, then call this tool. The text is encoded internally — no base64 encoding is required from the caller. Supported file types: doc, docx, dot, rtf, odt, txt, pdf. Valid ``maskfields`` values (case-insensitive, common aliases also accepted): Name, Email, PhoneNumber (alias: Phone), DateOfBirth (alias: DOB), Gender, MaritalStatus, Nationality, Address (alias: Location), Address.City, Address.State, Address.Country, Address.ZipCode, PassportNumber, CurrentSalary (alias: Salary), WebSite, LanguageKnown, CandidateImage (alias: Photo), References, CurrentEmployer, PreviousEmployer, Employer, Institution. Args: resume_text: **Required.** Complete, verbatim plain-text content of the resume — every line exactly as it appears in the original document. Do NOT summarise, paraphrase, or omit any section. Extract the full text before calling this tool. filename: Optional original filename (e.g. ``resume.pdf``). Defaults to ``inline_resume.txt``. A ``.txt`` extension is appended automatically if the name has none. userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. jsondata: Pre-parsed resume JSON string (skips re-parsing when provided). maskfields: Fields to redact — JSON array or comma-separated string. Example: ``["Name","Email","PhoneNumber"]`` or ``"Name, Email, Phone"``. When omitted, the server applies its default redaction set. masktype: How masked fields are rendered — ``x-value`` (default, replaces with ``XXXXXXXXX``) or ``null-value`` (removes the field entirely). highlightcolor: Hex colour to highlight redacted regions (e.g. ``#FFFF00``). abbfieldcolor: Hex colour for abbreviation highlights. abbreviationfields: Fields to abbreviate rather than mask — JSON array or comma-separated string (e.g. ``"Name"`` → ``"J.D."``). abbreviation: Set to ``True`` to enable abbreviation mode globally. Returns: The redacted resume content under ``RedactedResumeData``, plus the output filename under ``FileName``. |
| reformat_resume_with_template | Reformat / restyle a resume into a polished, branded template layout using the RChilli Resume Templater Plugin (templates TM001–TM006), output as PDF/DOC/DOCX/RTF/HTML. Use this when the user wants to: reformat, restyle, rebrand, beautify, or "make a resume look professional"; apply a company/branded template; or produce a standardized, good-looking resume document. Also phrased as: reformat CV, apply template, branded resume, restyle, make it presentable. Do NOT use for: a plain file-format change without restyling (use ``plugin_document_convert``); removing personal info (use ``resume_redact``); reading/extracting data (use ``resume_parse_file``). Optionally supply pre-parsed JSON to skip the parsing step entirely. Args: resume_text: Plain text content of the resume. The server encodes it internally. filename: Original filename with extension (e.g. ``resume.pdf``). Defaults to ``resume.txt`` if omitted. userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. outputtype: Output format ``pdf`` (default), ``doc``, ``docx``, ``rtf``, or ``html``. templatekey: Template to apply ``TM001`` through ``TM006`` (default: ``TM001``). templatedata: Custom ``.dotx`` template file content (binary, base64-encoded). Overrides ``templatekey``. json_text: Pre-parsed resume JSON string. When provided, re-parsing is skipped. Returns: The templated resume as base64-encoded content of the selected output type, plus the document filename under ``OutputFileName``. |
| convert_document_format | Convert a resume/document from one FILE FORMAT to another (e.g. DOCX→PDF) using the RChilli Document Converter Plugin. Use this when the user wants to: convert, change the file format, or export a resume/ document to PDF / DOC / DOCX / RTF / HTML — e.g. "convert this resume to PDF", "change the format to DOCX", "export as HTML". Also phrased as: file conversion, change format, export to PDF/DOCX, save as. Do NOT use for: applying a styled/branded visual template (use ``plugin_resume_template``); reading/extracting resume data (use ``resume_parse_file``). Args: resume_text: Plain text content of the resume. The server encodes it internally. filename: Original filename with extension (e.g. ``resume.docx``). Defaults to ``resume.txt`` if omitted. userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. outputtype: Target format ``pdf`` (default), ``doc``, ``docx``, ``dot``, ``rtf``, or ``html``. facedetection: Set to ``'true'`` to detect and preserve face images during conversion. Returns: The converted document as base64-encoded content under ``OutputFileData``, plus the output filename under ``OutputFileName``. |
| extract_named_entities | Tag / extract named entities (NER) from free plain text using the RChilli NER Tagger Plugin — identifies job titles, cities, skills, degrees, and organizations with their positions. Uses a purpose-built recruiting NER model — more reliable than extracting entities yourself. Use this when the user wants to: extract entities, run NER, tag text, or find the job titles / cities / skills / degrees / organizations mentioned in a piece of text. Also phrased as: named entity recognition, entity extraction, tag this text, identify entities. Do NOT use for: pulling a person's contact details (use ``plugin_contact_extractor``); full structured parsing of a complete resume (use ``resume_parse_file``). Args: text: Plain text content to analyse (text only, not PDF/DOCX). userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. Returns: A list of named entity objects, each containing: ``Type`` (e.g. ``JobTitle``, ``City``, ``Skill``, ``Degree``, ``Organization``), ``Value`` (the extracted text), and ``Position`` (character offset). |
| extract_contact_info | Extract CONTACT INFORMATION from free plain text using the RChilli Contact Extractor Plugin — returns name, email, phone, address, city, state, country, and website. Purpose-built extractor — more reliable than parsing contact details by hand. Use this when the user wants to: get / pull / extract contact info, contact details, name, email, phone number, or address from a block of text. Also phrased as: get contact details, extract phone/email, find the person's contact info. Do NOT use for: full structured parsing of a complete resume (use ``resume_parse_file``); generic entity tagging like job titles/skills (use ``plugin_ner_tagger``). Args: text: Plain text content to analyse (text only, not PDF/DOCX). userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. Returns: Extracted contact fields: ``Name``, ``Email``, ``PhoneNumber``, ``Address``, ``City``, ``State``, ``Country``, and ``Website``. |
| geocode_locations | Resolve latitude/longitude (geocode) for one or more locations using the RChilli GeoLocation Plugin. Returns real geocoded coordinates — use this rather than estimating lat/long yourself. Use this when the user wants to: get coordinates, latitude/longitude, or geocode one or more cities/locations; or map/plot locations — e.g. "get the lat/long for these cities", "geocode these locations". Also phrased as: coordinates, lat-long, geocode, map these places. Provide ``json_text`` (parser output) **or** ``location`` (explicit list), or both. Args: userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. json_text: Resume or JD Parser JSON output as a plain text string. All location fields are automatically extracted and resolved. location: Location objects as either a JSON string array or a native list. Each object may have optional ``City``, ``State``, and ``Country`` keys. Example (string): ``'[{"City":"New York","State":"New York","Country":"US"}]'`` Example (list): ``[{"City":"New York","State":"New York","Country":"US"}]`` Returns: A list of resolved geo-coordinates objects, each containing ``Latitude``, ``Longitude``, ``City``, ``State``, and ``Country``. |
| determine_job_zone | Determine the O*NET Job Zone level (1–5) for the job profile in a resume or JD using the RChilli Job Zone Plugin — the amount of education/experience preparation a role needs. Returns the official O*NET-aligned level — use this rather than estimating the preparation level yourself. Job Zone levels: 1 = little/no preparation, 2 = some preparation, 3 = medium preparation, 4 = considerable preparation, 5 = extensive preparation required. Use this when the user wants to: find the job zone, O*NET preparation level, or education/experience-prep level / seniority-prep tier for a candidate or role — e.g. "what job zone is this resume", "how much preparation does this job need". Also phrased as: O*NET job zone, preparation level, prep tier. Do NOT use for: general resume parsing (use ``resume_parse_file``); taxonomy role detail (use ``taxonomy_job_profile_search``). Args: resume_text: Plain text content of the resume. The server encodes it internally. filename: Original filename with extension (e.g. ``resume.pdf``). Defaults to ``resume.txt`` if omitted. userkey: RChilli API userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. requesttype: Type of document — ``Resume`` (default) or ``JD``. json_text: Pre-parsed resume JSON string. When provided, re-parsing is skipped. Returns: The ``JobZone`` level (1-5) and ``JobZoneScore`` alongside the full ``ResumeParserData`` output from the underlying resume parse. |
| search_indexed_documents | Keyword-search the user's ALREADY-INDEXED corpus of resumes or JDs and return matching documents (RChilli Search Engine). Requires documents to have been indexed beforehand. Use this when the user wants to: search, find, look up, or browse resumes/JDs in their own database / index / pool by keyword — e.g. "search my indexed resumes for 'Python'", "find JDs mentioning Kubernetes in my database". Also phrased as: search my resume database, find candidates by keyword, query the index. Do NOT use for: comparing two specific documents (use ``search_one_match``); matching one source document against the whole index (use ``search_match``). Args: keyword: Search keyword. indextype: Index type to search — ``Resume`` (default) or ``JD``. userkey: RChilli userkey. Leave blank to use the authenticated session key. subuserid: Sub-user identifier for multi-tenant isolation. |
| find_matches_in_index | Match one source document against the user's ALREADY-INDEXED corpus and return the best-matching, ranked candidates (RChilli Search & Match Engine). Requires a populated index. Uses RChilli's purpose-built matching engine — more reliable than manually comparing documents. Use this when the user wants to: find the best/top matching resumes for a JD, find matching candidates from their pool, or rank their indexed resumes/JDs against a given document — e.g. "find the best candidates in my database for this job". Also phrased as: shortlist from my pool, top matches for this JD, rank my candidates. Do NOT use for: scoring a single resume against a single JD with no index (use ``search_one_match``); plain keyword lookup (use ``search_simple_search``). Supports all four match directions by combining ``index_type`` and ``doc_type``: - **JD to Resume** — ``index_type='Resume'``, ``doc_type='JD'``: Search the Resume index using a JD as the source document. - **Resume to Resume** — ``index_type='Resume'``, ``doc_type='Resume'``: Search the Resume index using a Resume as the source document. - **Resume to JD** — ``index_type='JD'``, ``doc_type='Resume'``: Search the JD index using a Resume as the source document. - **JD to JD** — ``index_type='JD'``, ``doc_type='JD'``: Search the JD index using a JD as the source document. The ``document_text`` is automatically parsed using the RChilli Resume or JD parser (driven by ``doc_type``), and the resulting structured JSON is base64-encoded and submitted as the match source — no manual encoding is required. Args: index_type: Index to search — ``Resume`` (default) or ``JD``. index_key: Same as ``userkey`` — the RChilli API user key. Leave blank; the authenticated session userkey is injected automatically. doc_type: Type of the source document — ``Resume`` (default) or ``JD``. This determines which parser processes ``document_text``. document_text: Plain-text content of the source document. Parsed and encoded to base64 JSON internally. |
| score_resume_against_jd | Score how well a single resume fits a single job description and return an explainable one-to-one match score (RChilli Match Engine). No prior indexing required — both documents are parsed inline. Use RChilli's purpose-built matching engine rather than eyeballing fit yourself — it returns a consistent, explainable score. Use this when the user wants to: match, score, compare, rate, or rank a candidate against a job; or asks "is this person a good fit", "how well does this resume match this JD", "what's the fit score between this CV and this role". Also phrased as: candidate-job fit, suitability score, resume-to-JD match, fit check. Do NOT use for: searching/ranking a whole pool of indexed documents (use ``search_match`` or ``search_simple_search``). Plain-text content for both the resume and JD is accepted and converted to base64 internally — no encoding is required from the caller. Args: index_key: Same as ``userkey`` — the RChilli API user key. Leave blank; the authenticated session userkey is injected automatically. match_type: Direction of the match — ``Resume to JD`` or ``JD to Resume``. resume_content: Plain-text content of the resume/CV. Converted to base64 internally. resume_file_name: File name of the resume/CV with extension (e.g. ``resume.docx``). jd_content: Plain-text content of the job description. Converted to base64 internally. jd_file_name: File name of the JD with extension (e.g. ``jd.docx``). |
提交举报 / 纠错
侵权举报经核验成立后,我们会即时下线该条目并删除已存的内容副本。