Skip to main content
Glama

import_job_list

Import jobs from a LinkedIn or Indeed list open in your browser, match each to a tracked company board, and get counts, coverage and per-job outcomes.

Instructions

Take in a LinkedIn or Indeed job list the person had open ("Jobs based on your preferences", "Jobs that match your profile", "Jobs for you", a search's results), read in their own browser; jobwatch never fetches linkedin.com or indeed.com. Each job is matched to a tracked one (its link on the site, or its company and title); each new one is looked for on the company's own board and tracked there as new, whatever the filters say (they decide what get_digest shows); one not found there is tracked from the list's text and comes back as unplaced, with why (no board found, or not on it): find its board with find_board and watch it, and the alerts backfill fills it in. Each company counts toward list_suggested_boards. Returns counts (seen, tracked: jobwatch had it, earlier: an earlier import added it, added, unplaced) and coverage (jobwatch's own share: tracked over seen, 0-1; jobs an earlier import added count as missed), with a note when most of the list was imported before ("Same list as before: nothing new"), overall and by_source, and each job with its outcome and key. Every run is kept: jobwatch import-list --history shows the trend per site.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "records": "<records>"
    },
    "name": "import_job_list"
  }
}

Input Schema

NameRequiredDescriptionDefault
dry_runNoSay what would be tracked, and record nothing.
recordsYesThe jobs on a LinkedIn or Indeed job list page, as the extractor returns them: {source, id, title, company, location, pay, posted} each. Run the extractor (`jobwatch import-list --script` prints it) on the list's tab with the browser's JavaScript tool, its text followed by `await JWList.readAll()` (every page of a LinkedIn list in one call; on Indeed, `await JWList.readPage()` a page at a time, going to the link `JWList.next()` gives), and pass the records here.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv0.11.0

TDQS

A4.3/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond the annotations: it discloses the matching rule (site link, else company+title), the three-way outcome taxonomy (tracked / earlier / added / unplaced) with reasons, that unplaced jobs are tracked from list text and backfilled later, and that every run is retained. This is consistent with openWorldHint=true, destructiveHint=false and idempotentHint=false — the 'earlier: an earlier import added it' count explains why re-running is not a no-op.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded, but the body is a single dense run of semicolon-chained clauses with parentheses nested inside parentheses, which makes the outcome definitions hard to parse. Nearly every clause carries real information, so it is over-packed rather than padded, but readability and scannability suffer.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description fully carries the return contract: counts split into seen/tracked/earlier/added/unplaced, a 0-1 coverage ratio with its denominator semantics spelled out, a 'Same list as before' note, and per-job outcome plus key. For a two-parameter mutation tool with open-world reach, that is complete enough to call and to interpret results.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the schema itself already explains both records and dry_run at length, including the extractor invocation. The prose description adds no parameter-level detail beyond that (dry_run is never mentioned), so the baseline of 3 applies — the schema, not the description, carries parameter semantics here.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The first sentence names the specific verb and resource — take in a LinkedIn/Indeed job list read from the user's own browser — and immediately sets a hard boundary ('jobwatch never fetches linkedin.com or indeed.com'). It also distinguishes itself from siblings by naming get_digest (what filters affect), find_board (resolving unplaced jobs), and list_suggested_boards (company counting), so an agent can place it in the workflow without opening another schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage context is clear: call it when the person has a job list page ('Jobs for you', a search's results) open, and follow up on unplaced jobs with find_board plus watching. What's missing is explicit exclusion — nothing states when to prefer import_job_alerts or fetch_jobs instead, so the agent must infer the boundary between the list-import path and the alerts-backfill path.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.