Skip to main content
Glama

Nectar Jobs

Server Details

Search 1M+ live job postings: salaries, filters, similar roles and CV matching. Free, no account.

If you are the author of this connector, you can claim ownership by verifying the domain or GitHub account it belongs to. Claimed connector authors can inspect health checks, view analytics, and manage their listing.
Status
Healthy
Uptime
100.0% over the last 24 hours
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
Nectar Jobs

TDQS

A4.1/5.0

Scored across 7 tools

Disambiguation5/5

Each tool has a clearly distinct role: search_jobs finds listings, aggregate_jobs produces counts/breakdowns for a slice, get_stats gives corpus-wide coverage, job_trends analyzes change over time, get_job fetches one posting, find_similar_jobs anchors on a job, and recommend_jobs ranks against a résumé. The descriptions explicitly steer agents away from overlapping uses (e.g., aggregate_jobs vs. get_stats, search_jobs vs. aggregate_jobs), so boundaries are unambiguous.

Naming Consistency4/5

Six of seven tools follow a clean verb_noun pattern (search_jobs, aggregate_jobs, get_job, get_stats, find_similar_jobs, recommend_jobs). job_trends breaks the pattern as a noun phrase, which is a minor inconsistency but still readable and predictable overall.

Tool Count5/5

Seven tools is well-scoped for a job-market data service, with each tool covering a distinct need: discovery, aggregation, trends, stats, detail, similarity, and recommendation. No tool feels redundant or missing from a count perspective.

Completeness4/5

The surface covers search, details, aggregation, time trends, corpus stats, similarity, and résumé-based recommendation, which is strong lifecycle coverage for a read-only market data domain. Minor gaps remain around company-level profiles or explicit taxonomy/source listing tools, though aggregate_jobs and get_stats partially compensate.

Available Tools

7 tools
aggregate_jobsCount jobs in a slice of the marketA
Read-onlyIdempotent
Inspect

Aggregate counts for a filtered slice of the corpus — the tool for market/trend questions ("what kinds of roles are hiring in Pune?"), instead of issuing many limit-1 searches.

Takes the same filters as search_jobs (keyword matching included, see its ``query`` note) and
returns the slice's ``total`` plus breakdowns, each a {value: count} dict, biggest first:
``by_category`` (job function — the role-type axis), ``by_seniority``,
``by_employment_type`` (contract basis and hours in one axis; ``full_time`` is inflated because
a posting silent about its hours is recorded as full-time), ``top_companies``,
``top_skills``, ``by_source``, ``benefits``, ``company_size``, ``lang``, and ``salary`` —
per-currency posting counts with salary_max quartiles (currencies deliberately not blended).
Every count collapses duplicate postings, so numbers are comparable to search totals. A
breakdown on a field you filtered by lists only the values you filtered to.

Inputs: query, remote, source, company, +7 more. Returns: object

find_similar_jobsFind similar jobsA
Read-onlyIdempotent
Inspect

Find jobs semantically similar to a given job (excludes its duplicates).

At most ``max_per_company`` results per company (0 = uncapped; spellings of one employer, such
as "Thales" and "Thales Group", count together), so one employer's near-identical
postings don't fill the list; ``exclude_same_company`` drops the anchor's own company entirely
("roles like this elsewhere").

Inputs: job_id (required), limit, max_per_company, exclude_same_company. Returns: object

get_jobGet one job in fullA
Read-onlyIdempotent
Inspect

Fetch a single job's full details, including its description and any duplicate postings of the same role on other sources.

Inputs: job_id (required). Returns: object

get_statsIndex coverageA
Read-onlyIdempotent
Inspect

Return corpus-wide coverage: total jobs, counts by source, and top companies. For the same numbers on a filtered slice (a location, a company, a query), use aggregate_jobs.

Inputs: no named parameters. Returns: object

recommend_jobsMatch jobs to a CVA
Read-onlyIdempotent
Inspect

Rank jobs by how well they match a résumé or free-text description of what the candidate wants. Returns the best-matching jobs first.

``country`` (ISO-2, e.g. GB) or ``location`` (a city or region) is REQUIRED — ask the seeker
where they can work rather than guessing. Semantic ranking over every country returns the
nearest postings on earth, most of which the person cannot take.

``resume_text``: only about the first 400 words shape the ranking; anything after them is not
read. For a longer CV, send what defines the person's next role first: the role they want,
their headline, their recent roles and their key skills, not the whole document in order.

Ranking is purely semantic; the filters are hard. ``seniority`` (intern, junior, senior,
staff, principal, manager, director) filters to exactly that tag — many postings carry none,
so only pass it when the seeker insists.

Inputs: resume_text (required), limit, remote, country, +5 more. Returns: object

search_jobsSearch jobsA
Read-onlyIdempotent
Inspect

Search live job postings: use when the user asks what jobs are open for a role, a place, a salary or a skill. Each job carries url (its page on Nectar Jobs) and apply_url.

Args:
    query: keyword or natural-language query. Words that name an occupation ("manager",
        "software engineer") are matched against the TITLE; other words match the whole
        document (title, company, description), so a generic word's ``total`` overcounts —
        to compare role-type volumes, use aggregate_jobs instead.
    location: city or country substring over the posting's location text (matches broadly:
        "New York" includes the whole state). For a whole country, prefer ``country``.
    remote: filter to remote (true) or on-site (false) roles.
    salary_min: only roles whose salary range reaches this amount (raw number — currencies
        are not converted, so only meaningful combined with a single-currency market).
    company: company name substring.
    source: restrict to one source/board; get_stats lists the live sources and their sizes.
    seniority: one of intern, junior, senior, staff, principal, manager, director.
    category: job function from the site taxonomy (Engineering, "Data & ML", Product, Design,
        Sales, Marketing, "Customer Support", Operations, "Finance & Accounting",
        "People & HR", Legal, "IT & Security", …) — aggregate_jobs reports the live values.
    country: 2-letter ISO code ("US", "IN") — matches the derived country, more precise than
        a ``location`` substring.
    employment_type: contract or hours — permanent, fixed_term, contract, freelance, temporary,
        casual, seasonal, internship, apprenticeship, graduate, working_student, volunteer,
        self_employed, full_time, part_time, job_share, shift, term_time. Contract basis and
        schedule are one filter; a posting carries one of each. Note that a posting which says
        nothing about its hours is recorded as ``full_time``, so that value is the least
        informative of the set.
    posted_since_days: only jobs posted within this many days.
    mode: "hybrid" (default, best), "semantic" (meaning-based), or "keyword" (exact).
    sort: "relevance" (default), "date" (newest first), or "salary" (highest first).
    page: 1-based page number, for paging past ``limit`` results.
    limit: max results per page (1-100).
Returns a dict with ``total``, a ``jobs`` list (duplicates collapsed) and ``attribution``;
when nothing matched, a ``hint`` names the filter most worth loosening.

Inputs: mode, page, sort, limit, +11 more. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables searching, filtering, and applying to roughly 4,700 salary-transparent tech jobs across nine job boards and eight countries — plus Swiss all-industry and Singapore IT postings — directly from an AI agent. Returns results as structured JSON, supports salary, remote, tech, and country filters, and tracks which postings have already been applied to so duplicates never reappear.
      -
    • A
      license
      Not graded
      quality
      C
      maintenance
      Live normalized remote-job data across 5 boards — one keyless endpoint, one schema, skill fit-score. No API key required. Tools: search jobs by skills + salary floor, live market stats, and computed salary bands.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources