classify_subject_sector
ChatGPTClassify a subject company / fund / operating business into one of the 9 subject-sector buckets: Fund Manager / Investor, Technology & Software, Healthcare & Life Sciences, Financial Services & Fintech, Industrial & Materials, Consumer & Retail, Energy & Climate, Real Estate & Hospitality, Other / Unclassified. Returns the sector, a confidence score (0–1), and a source tag (cache | tier0_inline | uncached). When the source is "uncached" and the confidence is 0, the caller should treat the subject as genuinely unclassified and ask the user. These are the same 9 values get_scoping_area accepts as primarySubjectSector — when scoping a new background check, classify here (or map Intelligo industry data yourself) and pass the sector along.
compareCoverage
ChatGPTDiscover the report levels a client organization has and compare what each one covers, to understand the differences between levels and choose the right level for a use case. Report levels (tiers of background-check depth) and their coverage are custom per organization — never assume a fixed catalog; always discover first. Two-step usage: (1) call with NO levelIds to list the org's available report levels (each with id and name) and the coverage groups (report sections such as LEGAL, REGULATORY, KEY_PEOPLE). (2) call again with levelIds set to a subset of those ids to get a coverage matrix: every coverage item, grouped by section, with a per-level isCovered/isAvailable flag plus the item description and limitations. Use differencesOnly:true to return only items whose coverage differs across the chosen levels (the quickest way to see what a higher level adds). Optional groups restricts to specific sections. Because coverage varies by jurisdiction, levels are compared within a SINGLE jurisdiction (mirroring the UI): pass jurisdictionId to choose one, or omit it to use the org's default jurisdiction — the one actually used is echoed back as jurisdiction. Discovery mode also lists the org's jurisdictions. Coverage is computed for a PERSON subject by default; set entityType:"COMPANY" for company reports (coverage differs by entity type). Coverage reflects what a level includes, not findings for any individual subject.
createNewSearch
ChatGPTPrepare an Intelligo background-check search as a DRAFT on one or more subjects. IMPORTANT: this does NOT run a real search — it fills in the steps, saves a DRAFT and returns its Intelligo link. The user must open it, review (Review & Submit, in Intelligo) and submit there for the search to run. Make sure they understand this. Steps, in order: • Subjects (step 1) — put people in people and companies in companies (both optional; ≥1 subject overall). Do not ask Person vs Company: the array is the kind. Several of each allowed. • FCRA (person form type) is org-gated: offer ONLY if compareCoverage returned fcraAvailable: true — then FIRST ask: "Is this search being conducted for employment purposes in the US?"; use formType "FCRA" only on an explicit yes, else never mention FCRA. • reportTypeIds (step 2) — report types, REPORT_LEVEL ids from compareCoverage; one global list applied to every compatible profile. Omit ONLY for a monitoring-only draft. • addOnsByJurisdiction (step 2, OPTIONAL) — add-ons keyed by jurisdiction id → add-on ids, e.g. { "301": [331] }; ids from compareCoverage addOns. User picks per jurisdiction, or none (omit/{}). NOT report levels. • monitoringPackageIds (step 2, OPTIONAL) — monitoring, ids from compareCoverage monitoring.packages; each lands on every subject it fits, and monitoring.notApplied in the reply says who was skipped (relay it). • Project link (step 3, OPTIONAL) — attach every profile to ONE project: pass BOTH projectId AND projectName (from getProjects, or createProject). Omit both for none. • draftName (required) — ask at the end; default to the single profile's name, else a shared one. BEFORE CALLING: show the gathered scope as a TABLE (per-profile fields, report types, add-ons, monitoring, project, draft name) and get EXPLICIT approval; only call after the user confirms. Scope is validated BEFORE creation: on failure no draft exists and { success:false, errors } is returned — relay the specifics, do not retry.
createProject
ChatGPTCreate a new Intelligo project — a named aggregation of profiles — in the calling user's organization. The creator is granted access automatically. • name (required) — the project name. Names are unique per organization; if one already exists the tool returns { success: false, message } rather than creating a duplicate. • profiles (optional) — searchIds to seed the project with, i.e. the numeric searchId carried by a profile's reports[] (e.g. from getProfiles / getReportContent). Omit to create an empty project. On success returns { success: true, data } with the created project. This tool writes — it creates a record.
exportActionItems
ChatGPTExport action items to an Excel (.xlsx) workbook and return a presigned download URL (valid ~30 minutes) — the downloadable counterpart of getActionItems. Use this when the user asks to DOWNLOAD / EXPORT / "get an excel/spreadsheet of" action items (e.g. "download the open monitoring flags to excel"); use getActionItems to READ them inline instead. Same filter vocabulary as getActionItems, all optional and AND-ed together: - types: flag, review, refresh, upgrade, add_monitoring (omit for all kinds). - status: OPEN/IN_PROGRESS (unresolved) and/or RESOLVED/IMMATERIAL (addressed). - origins: origin LABELS, e.g. ["monitoring"]; matched case-insensitively against the org's origin names. No match -> nothing is exported and availableOrigins lists the valid labels to retry with. - profileId (the profile's own id from getProfiles, NOT a report searchId) and/or projectId; omit both for the whole org. - startDate/endDate (ISO) -> only items created in that window. MONITORING FLAGS to excel -> types:["flag"] + origins:["monitoring"]. Surface the returned downloadUrl as a link. Tenant- and permission-scoped to the caller.
exportPdf
ChatGPTGenerate a PDF export for Clarity report(s)/profile(s) or a whole project and return a presigned download URL (valid ~30 minutes). Provide EXACTLY ONE target: • `profileIds` → export the report(s) for those profiles. One report yields a PDF; multiple yield a .zip. • `projectId` → export the whole project. exportMode: SINGLE_PDF merges every profile into one document; MULTI_PDF returns a .zip (ignored for profileIds). The five include* flags mirror the UI export checkboxes — confirm with the user which to enable before calling. Tenant- and permission-scoped to the caller; surface the returned downloadUrl as a link.
getActionItems
ChatGPTList action items - tracked follow-ups Clarity raises on reports/monitoring. Each has a status (OPEN, IN_PROGRESS, RESOLVED, IMMATERIAL; last two = addressed), profileId, timestamps, updatedBy, origin codes + decoded originLabels, and a link. Users won't say "action item" - route plain language via types: - flags / red flags still open / audit flags -> types:["flag"] (open = status:["OPEN","IN_PROGRESS"]). - report reviewed? / who reviewed it / not reviewed -> types:["review"] (reviewed = RESOLVED; reviewer = updatedBy/updatedAt). - ANY recommendation question - "do you have recommendations?", "what do you recommend for X?", "what should I do with this subject?", "needs a refresh/upgrade/monitoring?" -> types:["refresh","upgrade","add_monitoring"]. "Recommendation" means Intelligo's TRACKED ones, NOT your own advice: fetch them here FIRST, never infer from flag counts. Each carries recommendation.reasons (why) + recommendation.triggeringFindingCount. The raw triggering-finding ids are NOT returned (opaque internal ids, never for the user); to see the findings use the item's link or drill in via its _id. Scope with profileId (the profile's own id from getProfiles, NOT a report searchId) and/or projectId; omit both for the whole org. Narrow with status. Omit types for all kinds. MONITORING FLAGS: "are the monitoring flags handled / who resolved them?" -> origins:["monitoring"] + types:["flag"], read status/updatedBy. origins matches the org's origin names case-insensitively; no match -> empty with valid availableOrigins. (For what is NEW this period use the monitoring FEED tool.) LINKS: ALWAYS render each item's link (verbatim) without being asked - it deep-links to the triggering finding, else its report tab, else the profile. DETAIL: a short page (<=5) gives each item its full detail (detailIncluded:true); otherwise drill in by passing the rows' _ids as itemIds (also for "tell me more / dive into these"). Tenant- and permission-scoped.
getCompanyEmployees
ChatGPTFind the people who work at a company, from Intelligo's data. Takes a company id (NOT a name), so results are ALWAYS scoped to exactly one company: FIRST call getProfiles with profileType: "company" to resolve the company and read its id, then pass that id here. Optional filters narrow the list: role (wildcard — "marketing" matches "Marketing Manager", "VP of Marketing"), seniorities, departments, and locationCountry. Returns matching employees with their role, seniority, departments, industries, location, and tenure dates. The company is validated against the dataset FIRST: when it is NOT in the dataset, found is false and employees is empty (meaning there is no data for it — NOT that nobody matched). NOTE: this LISTS people at a company; to resolve a single named subject (and learn whether the org already has reports on them) use getProfiles.
getMonitoringFeed
ChatGPTRead Clarity's monitoring feed — the consolidated stream of new findings from ONGOING MONITORING of the org's subjects. Once a subject is placed under monitoring, Clarity keeps re-scanning sources and records each newly-detected material event as a finding. This is the data behind Clarity's monitoring dashboard — the answer to "what has changed across my portfolio?". Use this tool for WHAT IS NEW / what changed in a window (time-scoped by when monitoring picked a finding up). It is NOT the place to reconcile flag STATUS: for whether monitoring flags are still OPEN or already HANDLED, who handled them and when, or an audit by status, use getActionItems with types:["flag"] and origins:["monitoring"]. Each finding is tied to a monitored subject (profileId + profileDetails) and carries its source(s), the dates it was first/last seen, a match-confidence band, a per-finding review state, and relatedFlags[] (each flag has a numeric level, is system- or analyst-added, and is enriched with the action items opened on it and their status). All filters are optional and AND together; omit them all for a portfolio-wide feed (see each parameter). Paginate with limit (default 20) and cursor (page number as a string); findings are ordered newest-seen first. For subject-level questions ("which subjects are most flagged?"), read the feed and group findings by profileId/profileDetails. Tenant- and permission-scoped to the caller. Monitoring is an ongoing feed — NOT a static report. For a subject's produced reports use getReportContent / exportPdf instead.
getProfiles
ChatGPTList or resolve subjects (people or companies) for the calling org. FIRST searches the org's OWN Clarity profiles, tenant-scoped (the data behind Clarity's main dashboard list). A profile is the top-level entity Clarity maintains per subject — a person or company — that aggregates everything known about that subject across all of its reports and stays current as reports are added, refreshed, upgraded, or monitored. Each row carries a reports[] array: a report is one produced report at a given report level (type), and a single profile may hold several report levels plus refreshed/upgraded versions of the same report — the profile rolls them all up into aggregate fields such as flag/result counts, monitoring state, latest identification date, and workflow status. name_query is an OPTIONAL free-text token-prefix filter over subject names (the same matcher the dashboard search box uses); OMIT it to list all profiles in the org. Paginate the account list with limit and cursor (page number as a string). If name_query is given but matches NO profile in the account, the tool resolves the subject from Intelligo's wider data instead, so the caller still gets a result. The top-level source reports which happened — "account" (the org's own profiles) vs "intelligo_data" (resolved from Intelligo's data, NOT in the account). EACH returned profile carries inAccount, plus hasReports/reportCount — whether Clarity already holds BACKGROUND REPORTS on the subject (derived from its report version history; an empty history means none). profileType (person|company, default person) only affects resolution from Intelligo's data (which currently supports people only); the optional firstName/lastName/jobTitle/company hints help pinpoint the subject there. Account rows are returned verbatim from the profile aggregation (profileId, title, subTitle, status, reports[], monitoringCount, isMonitored, …) — not a flattened shape. Every account profile ALSO carries a versionHistory[] array — the complete chronological list of that subject's reports. Whereas reports[] shows only the LATEST published report of each category, versionHistory[] ALSO includes older, superseded reports (flagged isOldVersion: true). An old version almost always means the client refreshed the subject (re-ran the same report level later) or upgraded it to a higher report level — tell the two apart via each entry's scrapingPackageName (the level/tier, e.g. Advantage - Level 1 vs Advantage - Level 3), since isOldVersion alone does NOT encode refresh-vs-upgrade. Each entry's searchId joins back to a reports[].searchId and can be passed to getReportContent, so a skill can read both an old and the current report to compare a refresh.
getProjects
ChatGPTBrowse Clarity projects — a project is a named aggregation of profiles. Two modes: • Omit `projectId` → list projects. Returns { projects: [...] }, the calling user's accessible projects (name, timestamps, labels, collaborators, and a flag/profile-count summary). Optionally narrow with name (case-insensitive substring) and page with limit/cursor. This is the correct way to answer "show my projects". • Provide `projectId` → one project in full. Returns the project's metadata, rollup counts, permissions, feed notifications, and profiles[] — verbatim profile rows whose reports[] searchId chains into getReportContent. Tenant- and permission-scoped to the caller.
getReportContent
ChatGPTRead a Clarity report's content as the client sees it rendered in the UI, returned as structured JSON per tab. A report is identified by its searchId — obtain it from getProfiles first: each profile's reports[] array carries the searchId of every report level it holds. Two-step usage: (1) call with ONLY searchId to discover the report — returns metadata plus the list of available tab names (e.g. EXECUTIVE_SUMMARY, LEGAL, KEY_PEOPLE). (2) call again with tabs set to the subset you want; each requested tab is rendered live and returned as structured JSON (sections → tables / lists / key-values / text). Each returned item carries an id (its data-item-id) — pass those ids to the getSources tool to retrieve the sources (publishers + links) behind the item. Rendering is slower than a plain data read, so request only the tabs you need (max 10 per call). Unknown tab names are rejected with the available list; a per-tab render failure is reported in an errors[] array rather than failing the whole call. PDF-only reports are handled automatically: the tabs param is ignored and the call returns the report's extracted PDF text (as a PDF_REPORT tab) plus the structured EXECUTIVE_SUMMARY tab.
getSources
ChatGPTRetrieve the underlying sources behind report items — the publishers and links each item's data was drawn from. Item ids come from getReportContent: every rendered item carries an id (its data-item-id). Pass one id to cite a single item, several ids for a few items, or every item's id from a tab/report to cite the whole thing. Returns, per item, a list of sources where name is the source/publisher and urls are its links. Item ids that don't exist, or that belong to a report the caller is not authorized to read, are returned in notFoundItemIds.
get_scoping_area
ChatGPTStep 2 of a NEW background check — after getProfiles resolves the subject. Given a subject company/fund, returns the recommendation ENVELOPE for the AUTHENTICATED user's client (the OAuth session provides ownerOrg): how many subjects (split between persons and companies), what depth (fast_screen / standard / full), and what key-person seniority tier (KP_C_SUITE et al), plus a plain-language rationale. The recommendation comes from a Bayesian blend over THIS client's own historical projects in the same (client × subject sector) cell, falling back to the cell-wide default when the client has little history. Returns one of two shapes. status: "ready" carries the area + context + assumptions — for every pattern-cascade field that mattered (subject type, IB transaction type, IB counterparty, IB person focus, PE_LMM add-on), assumptions says whether you supplied it (source: "explicit") or the backend defaulted it (source: "default") and gives the allowed enum values. You MUST surface every `default`-sourced assumption to the user in plain language ("I assumed this is M&A advisory; if it's actually restructuring, tell me"). If the user corrects any value, re-call this tool with the correct value in subjectTypeConfirmed / ibContext.* / pelmmIncludeAddOn. status: "needs_clarification" survives in only two cases: (1) the LLM didn't pass a subject name → asking="primary_subject_name"; (2) the client is Pattern B (Asset Manager) and subjectTypeConfirmed is null → asking="subject_type" (options: fund_manager / opco / ib_advisory). Relay it, then re-call with subjectTypeConfirmed set. Never modify the area numbers manually — they reflect the algorithm. The returned context carries everything get_scoping_profiles needs to build the person + company list; after selection, compareCoverage translates the tier + countries into org report-level/jurisdiction ids and per-selection add-ons (offerableAddOnIds), then user approval, then createNewSearch (draft).
get_scoping_profiles
ChatGPTGiven an approved ScopingArea + the resolved context (both from get_scoping_area), returns the FIXED company entities (companies) plus the key-person CANDIDATE POOL (candidates) and recommendedPersonCount. The backend resolves employees from context.primarySubjectId, filters to area.kpLevel, folds in any websiteProfiles you supply, and hands back the whole eligible pool (up to 15) — Workforce tenure on every row, full LinkedIn detail when enrich:true. It deliberately does NOT pre-pick the "best" people. YOU select the key persons: choose recommendedPersonCount from candidates to actually run, treating the rest as the swap pool. Rank by tenure (roleStartDate / companyJoinDate), role seniority, founder status, and the client's historical layer pattern, plus your own knowledge — and drop obvious wrong-person matches (an enriched profile with no real tie to the subject). After this returns you own the JSON: add a named person, drop a row, move someone between the selected set and the pool, exclude a role, relabel — all by editing in conversation, not by re-calling (re-calling rebuilds from scratch and burns a fresh Workforce lookup). The skill scope-new-project walks through selection + the per-edit recipes. Your accumulated copy is the user's scope — next, bridge it to org terms with compareCoverage: map recommendedReportLevel (basic/medium/full) to the closest org REPORT_LEVEL id, map each subject's ISO country codes to org JURISDICTION ids, and propose add-ons ONLY from compare-mode offerableAddOnIds for the chosen level+jurisdictions (discovery's addOns gives names, not availability; verify picks via addOnIds). Present the full scope (subjects, levels, jurisdictions, add-ons) for the user's explicit approval, then createNewSearch saves it as a DRAFT the user submits in Clarity.
semanticSearch
ChatGPTSearch the org's due-diligence reports by MEANING — the ENTRY POINT when you don't yet know which subject or report to look in. Pass ONE concrete topic (e.g. "financial fraud", "sanctions or PEP exposure", "violent crime arrests"). When the question points at a report area, also set sections to rank that tab higher (e.g. court cases → ["LEGAL"], adverse media → ["NEWS"], sanctions/PEP → ["REGULATORY"]). Returns matched reports best-first, each with searchId, profileId, bestSimilarity (0–1), and sections → passages: the VERBATIM report text that matched, with a per-passage similarity. The passages ARE the evidence — read them to answer; you usually do NOT need to re-open the report. NEXT STEP: act on the searchIds returned HERE. To read more of a specific hit, call getReportContent with THAT searchId directly — it already is the report id, so do NOT call getProfiles to look it up and do NOT list profiles. Use getProfiles(profileId) only to view the whole subject. total = how many matched; if it exceeds the number returned, tell the user and raise limit or narrow the topic. Auto-scoped to your org. LIMITS: vague/multi-topic phrases ("red flags", "anything concerning") retrieve poorly — for a broad ask, run a few concrete topics and merge. Hits are topical CANDIDATES, not confirmed findings: a high score on a screening section (sanctions, PEP, watchlist) usually means the report HAS that section, not that the subject is flagged — confirm the actual finding in the passage text. It IGNORES query constraints (dates, locations, counts, exact names, AND/OR) and cannot count, enumerate, compare, or prove absence; no hits ≠ absence. For an exact name or case number, prefer getProfiles.
submitMcpFeedback
ChatGPTSubmit feedback about THIS MCP server's own tools, so the Intelligo team can improve them. Intelligo Clarity's first MCP server - capturing tool feedback is high value. WHEN to call (any of these): - a tool returned an error, or wrong / irrelevant results; - the user is frustrated or confused, or repeats a request that just failed; - the user praises or criticises a tool, or wishes one existed ("I wish there was a tool for X"); - you are about to report a task complete and a tool got in the way. VALID feedback targets THIS server's tools, e.g. "semanticSearch returned irrelevant passages", "I wish there was a tool to list monitoring subjects". INVALID - do NOT submit: complaints about the report DATA / findings, the AI model itself, or the IDE / client. Only feedback about THIS server's tools. source="user": the feedback is the human's - quote their exact words in quote. source="agent": you (the agent) observed a tool misbehave - put your own one-line observation in quote. PRIVACY: never put report content, a subject's name, or any personal data in quote or context. Describe the TASK TYPE ("running a due-diligence report"), not who it concerns. Feedback is stored by Intelligo for product improvement only. Call at most once per distinct issue; never re-submit something already reported this session.
updateMonitoringFindings
ChatGPTWRITES. Marks monitoring findings as reviewed — the "Mark as reviewed" action on a finding in Intelligo's monitoring dashboard. It records the caller as the reviewer and clears each finding from the unreviewed count / getMonitoringFeed's unreviewedOnly view. Users call these findings alerts ("mark those alerts as read") — same thing. Pass EVERY confirmed finding in ONE call (up to 50) as findings: [{profileId, findingId}], taking both ids from getMonitoringFeed. Findings may span different subjects. NEVER call this tool repeatedly to walk a list one finding at a time. CALL ONLY WHEN the user has, in the CURRENT turn and in their own words, asked to mark / acknowledge / clear specific monitoring findings or alerts ("mark that one reviewed", "mark all five of those as read"). First state WHICH findings you are about to mark (name them, or the exact count), get an explicit yes, then make the single call. A user merely reading, discussing, or asking about findings is NOT intent: you may OFFER, you may not act. Do NOT use this tool for: • action-item or FLAG status ("mark this flag handled / resolved", "close this action item") — different concept, different tool; read flag status with getActionItems (types:["flag"]); • the report-level reviewed checkbox — that is getActionItems types:["review"]; • answering WHAT is or is not reviewed — that is a read: getMonitoringFeed unreviewedOnly. "Mark everything on this subject": read its unreviewed findings from getMonitoringFeed, confirm the count, then pass those ids; beyond one page, point the user to "Mark as reviewed" on the subject's card in the dashboard, which clears it all at once. results has a row per finding: part of a batch can succeed while the rest fails — always relay message. This tool ONLY marks reviewed: re-marking is harmless, un-reviewing is NOT possible here. Requires a full user seat and is tenant- and permission-scoped per finding.