document_changes
ChatGPTOnly what changed in a lot's stored tender documents between two versions (a corrected notice publishes them again). Takes the same notice_id / lot_id as lot_details; from and to name versions the way lot_documents version does — by default the version before the current one and the current one. File level, on every plan: files lists each file that was added, removed or changed (same path, different bytes), and unchanged counts the rest. An added file comes with docType and byteSize: read it with document_download (format "text"). Text level: a changed file with textChanged: true has its changes in textChanges — the changes the lot page highlights. Each change gives the heading path of its section, its kind (changed, added, removed) and the passage, with the changed words marked [-old-]{+new+}; a changed table row comes with the table's header row. textChanged: false means the same text in new bytes (e.g. a re-export); null means a copy has no converted text yet. Text changes are paged: each answer carries up to maxChars characters of them (default and max 40000); pass nextCursor back as cursor, with the same other arguments, until it is null. files is the same on every page. A changed row with locked: true withholds its text changes from this caller (reason: plan_required means document text needs a paid plan, withdrawn that the document was taken down); the file level stays. When from and to cannot be compared — unknown, the same, from not older than to, or only one version stored — the invalid_input error lists the versions that exist.
document_search
ChatGPTFind WHERE a topic is discussed in one lot's stored tender documents: full-text search over the extracted text of the lot's current files, answered as (file, page) hits with a short snippet each. Takes the same notice_id / lot_id as lot_details. Use it before reading: to answer "what does this tender say about X", search X here, then read the hit's page with document_text(notice_id, lot_id, fileId, page) for the context — snippets are the only text this tool returns. Matching is German full-text search (stemming, stop words; exact word forms still match in other languages) and is PER PAGE: a hit is a page on which all the words occur, so a query whose terms sit on different pages returns nothing — use one or two key terms, or OR them, rather than a question. "quoted phrases" match as phrases, -word excludes. filesSearched and filesWithoutText say what the search covered: a non-zero filesWithoutText means some files have no extracted text (scanned, pending), so a miss is not proof of absence — lot_documents lists them with textStatus. locked: true means the caller's plan does not include document text (lockedReason). Searches one lot's current version only; there is no cross-lot or semantic search.
document_text
ChatGPTRead the extracted text of ONE stored tender document, one page at a time. Takes the lot's notice_id / lot_id and a fileId from lot_documents (call that first — it also tells you via textStatus whether text exists). Paging: ask for page: N (1-based, pageCount in the answer is the total; a page past it is an invalid_input error) or continue a slice with cursor: nextCursor; a nextCursor of null means the text is exhausted. Every answer belongs to exactly one page — a cursor continues within the page it points into and the next cursor opens the following page — so page is always the page the slice came from. Each answer is capped at 20000 characters (maxChars lowers it), so a long page spans several cursor steps. Cite what you quote by fileName and page. status not_extractable (e.g. a scanned PDF, reason says why) or pending (not processed yet) means there is no text: hand the user downloadUrl so they can open the file themselves. partial returns the text that could be extracted plus the reason and the download link. locked: true means the caller's plan does not include document text (lockedReason); the list from lot_documents is still available to them.
entity_search
ChatGPTResolve a free-text mention to canonical entities — products, organizations/parties, manufacturers, NUTS regions, market domains, market segments. Call this FIRST when the user names something (a vendor, a product, a place, a market sector); then pass the returned ids/names as structured filters into market_overview / lot_search / org_details / lot_details. Mapping: result.type "product" → pass value in products: [...]; "organization" → pass id in party: [{id}] (buyer-side); "manufacturer" → pass id in manufacturers: [{id}] (vendor-side, carries product_count); "nuts" → pass id (the code) in nuts: {id}; "domain"/"segment" → pass id in domain / segment. A party that plays both roles surfaces twice (once as organization, once as manufacturer) with the same id; pick by intent. A product row with has_manufacturer_party: false is community-maintained OSS — pass via products: [...] only and do not expect a manufacturer filter to resolve it. Manufacturer and organization searches are gated to query length ≥ 3 (products and domains run at length ≥ 2); a 2-char query like "MS" returns only products + domains by design. For full enumeration of domains/segments (no keyword to fuzz), use taxonomy_browse. Skip this tool when the user already gave you an exact id or code.
feed_create
ChatGPTSave a search as one of YOUR feeds, so it can be reopened in the app and reused here as feed: {id|name}. Takes the SAME filter vocabulary as lot_search — you never build the website payload by hand — plus a name and an optional view picking which page the feed opens. Two arguments lot_search has are absent: feed (a feed cannot be defined in terms of another) and country (a feed stores its own country from the filters you pass). A filter a saved feed has no field for comes back in dropped_filters rather than being stored silently — read it, because the feed you created is wider than what you described by exactly those. Requires the saved-items WRITE setting.
feed_details
ChatGPTWHAT ONE of YOUR saved feeds actually filters by, in the same vocabulary lot_search takes — so you can explain the feed in words, hand any of its filters straight back, or narrow one of them. feed_list names your feeds and the feed reference runs a call under one; this is the tool that says what a feed MEANS. Filters come back in the ARGUMENT dialect these tools accept, so you can pass any of them straight back to lot_search rather than decoding a stored format. A feed storing something this API cannot express still answers here, with those keys named in unsupported_filters and usable: false — the same verdict the feed reference reaches, so the two never disagree about whether a feed is runnable. Describing such a feed is honest; USING it would silently widen the query, which is why the reference refuses it. Reference the feed by id or exact name. A feed you cannot see reads as not found. Requires the caller to have allowed AI assistants to use their saved items.
feed_list
ChatGPTList YOUR saved feeds — the searches you saved in GovIntelligence, your own plus the ones your team shares with you. The discovery counterpart to the feed reference on lot_search and market_overview: call this to learn the ids and names, then pass one as feed: {id|name} to run a question under that feed's stored filters. Each row carries id, name, the path it opens, is_own, shared, and usable. READ usable BEFORE PASSING A FEED. A feed can store filters this API has no way to express (per-organization role rows, the manufacturer-folder facet, "no manufacturer"); those come back usable: false with unsupported_filters naming them, and passing one is refused rather than answered more widely. Feeds are USER/TEAM-scoped, like folders: the same name may resolve to a different feed for a different caller, and one you cannot see is indistinguishable from one that does not exist. Optional nameContains filters by a case-insensitive name substring. persistent_url opens the /saved/feeds page. Call feed_details for what one of them actually filters by. Feeds can be created and changed with feed_create / feed_update, which need the separate WRITE setting; there is deliberately no delete and no share.
folder_create
ChatGPTCreate one of YOUR organization folders — a named group of i2_party organizations you can then filter by with folder: {id|name} on lot_search, market_overview and signals_feed. NOT a contract folder: /folder/[folder_id] on the website is a procurement procedure, which this has nothing to do with. Pass party_ids to fill it at the same time; resolve names to ids with entity_search first. Organizations only — lots cannot go in a folder. RETRY-SAFE: if you already have a folder with this name you get THAT folder back with created: false, never a duplicate and never an error. Requires the caller to have allowed AI assistants to CHANGE their saved items; without it the call answers setting_disabled naming the setting.
folder_details
ChatGPTWHAT IS INSIDE one of YOUR organization folders — the organizations it holds, paginated, each with the id you can pass to org_details or back as party: [{id}]. folder_list names your folders and lot_search filters by one; this is the tool that says who is actually in it, so you can answer "who are my competitors?" rather than only "search within my competitors". PAGINATED because a folder is not a short list — bulk-filled folders routinely hold thousands. search filters over the WHOLE folder rather than the current page, which is how to answer "is this organization in here?" without paging through all of it. Reference the folder by id (from folder_list) or exact name; an ambiguous name returns candidates and an unknown one returns suggestions, like the folder facet. A folder you cannot see reads as not found. Requires the caller to have allowed AI assistants to use their saved items.
folder_list
ChatGPTList YOUR visible organization folders — named groups of organizations (i2_party) you own, plus folders shared with your team and your team's own folders. Each row carries id, name, org_count, visibility ("private" | "shared" | "team"), is_own and managed. managed means GovIntel provisioned the folder and owns its lifecycle — you can change what is IN it but not rename, delete, share or move it. It is orthogonal to visibility: a team folder is always managed, and a folder assigned to you personally is private, is_own: true AND managed. A "team" folder is owned by your team itself rather than by a person: everyone on the team can use it, nobody is its owner, so is_own is false for all of you and there is no "shared by" person to attribute it to. This is the discovery counterpart to the caller-scoped folder facet on lot_search: pass a returned id (or exact name) as folder: {id|name} to filter lots to that folder's member organizations, or to folder_details for the organizations it actually holds. Folders can be created and changed with folder_create / folder_update, which need the separate WRITE setting; there is deliberately no delete and no share. Folders are USER/TEAM-scoped — unlike every other entity in this API, the same folder name may resolve to a different folder (or to nothing) for a different caller, so always resolve names via YOUR own folder_list rather than assuming a shared vocabulary. Optional nameContains filters the list by a case-insensitive name substring. persistent_url opens the /saved/folders page.
lot_details
ChatGPTFull lot detail aligned with /procurement/[notice_id]/[lot_id]: lot/notice metadata, CPV, organizations, results, products, related news. Use the notice_id and lot_id returned by lot_search items. lifecycle_phase and is_awarded are promoted to the top level of data (they are also on the lot object) — quote the phase rather than deriving lot status from notice types. data.lot is a declared field projection, not a database row dump: every field it can carry is in this tool's outputSchema, and a date field appears ONLY when the lot has that date — a missing award_date or planned_period_start means "not published", so do not read its absence as an error or retry for it. The same rule applies to results[] and notice_documents[]. All date fields are ISO 8601 datetimes in UTC. lot.aggregated_payload carries the four curated keys kept from the source notice JSON (award_criteria, document_links, access_tool, framework_agreement); the notices themselves are listed in notice_documents[] for identification only — their bodies are already parsed into the rest of the response, so there is nothing further to extract from them. documents summarises what the pipeline has stored for the lot (storedFiles, readableFiles, versions, latestVersionDate, unfetchedLinks): call lot_documents for the rows when storedFiles > 0, and document_text to read a file once readableFiles > 0.
lot_documents
ChatGPTThe tender documents stored for a lot — the files its published links served (Leistungsbeschreibung, Vertragsbedingungen, Anlagen, …), one row per file, with ZIP members listed under their archive. Takes the same notice_id / lot_id as lot_details. Documents are stored per published link, and a notice usually publishes one link for all its lots: the lots in sharedWithLots hold exactly these files with the same fileIds, so reuse the ids for them instead of listing again; a lot missing from that array has a different set (its own documents, or a newer version) and needs its own call. Each row carries textStatus: when it is extracted or partial, read the content with document_text(notice_id, lot_id, fileId) — this tool lists, it does not return text. readUrl opens the lot page with the file's content shown; downloadUrl is the app download route for the original file. Both need a browser session, so hand them to the user as links rather than fetching them yourself; downloadUrl redirects to a short-lived file link after the app checks the user's plan. document_download gives links that work without a session, and the converted text of several files in one call. A row with locked: true is withheld for this caller: plan_required means text and download need a paid plan (the list itself is always visible); host_blocked means the publisher asked for the file not to be redistributed — tell the user where it was published (sourceUrl). unfetched lists published links the pipeline could not fetch (e.g. a portal that needs a login); point the user at sourceUrl for those. changes tells whether a file changed between versions of the lot's documents (same path, different bytes): fromPrevious compares with the version published just before, fromFirst with the first ever — use it to point a user at what a corrected notice actually changed. versions[] lists every version; pass one of its noticeIds (or "previous") as version to list that version's files with their own fileIds — document_text reads them too — and changes.fromCurrent then says how each differs from today's file. Empty documents and unfetched means nothing has been stored for the lot; lot_details keeps the raw published links in lot.aggregated_payload.document_links.
lot_incumbents
ChatGPTGiven a lot, return the buyer's historical preferred-vendor concentration: which vendors the buyer has repeatedly awarded similar contracts to, at four taxonomy levels (domain, segment, manufacturer, product). Powered by the same query that backs /api/procurement/[notice_id]/[lot_id]/incumbents. Highest-signal capture-mode answer ("I am bidding on this — who is the incumbent I need to beat?"). Insights are filtered by minimum group size (≥5 lots) and dominant share (≥60%) before bottom-up generalization (e.g. if all products under SAP are awarded to the same vendor, the manufacturer-level row absorbs the product-level rows). Empty insights array means the buyer has no concentrated patterns above those thresholds — a real signal in itself ("competitive market"). Use the returned vendor_party_id directly with org_details to learn more about the incumbent.
lot_related
ChatGPTGiven a lot, return other lots related to it via similarity matching — overlapping CPV + similar name, same segment + overlapping CPV (or same segment alone when the lot has no CPV codes), overlapping canonical products, or overlapping manufacturers. Powered by the same query that backs the website /procurement/[notice_id]/[lot_id]/flow page. This is a similarity traversal, NOT a filter — it cannot be expressed via lot_search. The natural follow-up after lot_details for "what else is this buyer doing similar to this contract?" Each related lot carries a tier array showing which dimension(s) matched, plus the matched CPV codes / products / manufacturers when applicable. Default scope is "buyer-only" (capped at 100 related lots from the same buyer). Pass scope: "full" to widen across all buyers (no cap; can be heavy). Every row (and the echoed source_lot) carries lifecycle_phase, so you can tell which matches are still biddable from which are running or finished contracts without a second call. Paginated: page / pageSize (default 20, max 40 — a lower ceiling than lot_search, because these rows are fatter and a bigger page would not fit a client tool-result limit), with total = rows available to page through and total_matches = the uncapped tier count. Rows are ordered by lifecycle relevance first (open, then pre-tender, running, closed, unawarded, expired) and recency second, so page 1 is what is still actionable rather than merely what was announced last. The ordering is applied by the traversal itself, BEFORE its 100-row cap, so in "buyer-only" scope the rows you can page through are the 100 most relevant matches rather than the 100 most recently announced. Rows are lean on purpose: one flat url per row (no tracking parameters — the self-describing link object is on the envelope persistent_url only), buyer and winner as {id, name} (expand either with org_details), no row buyer at all in "buyer-only" scope (it is data.buyer), and project_name / matched_products / matched_manufacturers absent when they would add nothing.
lot_search
ChatGPTPaginated lot list with the full F1 filter set (date windows, party roles, winner/milestone flags). The optional view parameter targets a specific lot-listing page on the website — procurement (default, all lots), awards (an award event happened), expiring (every running contract, soonest end first), capture (lifecycle phase "open", i.e. bidding is genuinely open) — and routes persistent_url to the matching path. Returns one row per lot with: title, buyer, winner (when known), estimated/awarded value, submission_deadline, publication_date, top_cpv, top_nuts, lifecycle_phase, is_awarded, and a detail URL. lifecycle_phase is the database's own phase for the lot (pre-tender / open / closed / unawarded / active / potentially active / expired) — read it instead of inferring a status from notice types or from the presence of a winner. It is orthogonal to is_awarded: an awarded lot can be active, expired or unawarded. Filter on it with the phase argument, which narrows any view; the retired "other" view (tenders that ran and were not awarded) is phase: ["unawarded"], listed on the website at /procurement?phase=unawarded. Arguments are validated strictly: an argument this schema does not list is an error, never a silently ignored filter — if a call fails on an unrecognized key, use the declared argument instead of retrying without it. Tip: when the user names a vendor, product, region, or sector, do NOT put those names in query/searchTerms. First call entity_search to resolve them, then pass the canonical ids/names as structured filters (manufacturers, products, nuts, domain, segment). Reserve query for thematic phrases like "AI" or "cloud migration". When free-text input is provided, the response also carries meta.search_semantics (which DB columns the SQL hit, language handling, OR/AND logic), and may include meta.warnings (your free-text term matched a known product/manufacturer — consider the structured filter) or meta.did_you_mean (zero hits but the term resolves to an entity — retry with the example_filter shown).
market_overview
ChatGPTAggregate market summary aligned with /analytics: a summary header (total_lots, lots_with_known_winner, value with coverage, latest_publication_date_range), top vendors, top buyers, top manufacturers, procedure breakdown, framework breakdown, two quarterly histograms (lotCountsByPublicationQuarter on the filter axis, lotCountsByLatestActivityQuarter on the lot-rollup axis). Accepts F1 filters honored by /analytics; lot-only filters (latestPublicationDate, plannedDate, expirationDate, submissionDeadline, partyRoles, knownWinnerOnly, requireMilestoneDates) are not accepted here — use lot_search for those. Arguments are validated STRICTLY: an argument this tool does not declare is rejected, never ignored, so a rejected call is a call to fix rather than a wider answer to mistrust. The lifecycle-phase facet IS honored: phase: ["open"] narrows every aggregate to lots in that phase, the same population /procurement?phase=open lists and the returned /analytics persistent_url opens. Use it to split a market by stage — what is out for bid now, what is running, what is expiring — instead of reading a stage out of the procedure or framework breakdowns. Always summarise the market from summary first: it is the only field that gives the true market size (total_lots), the share of lots attributable to a vendor (lots_with_known_winner), and a coverage-aware value total. Do NOT sum lotCountsByLatestActivityQuarter[].count for market size (it drops lots without publication dates and is bucketed on i2_lot.latest_publication_date, NOT the publicationDate filter axis) or topVendors[].count for vendor reach (it is LIMIT-truncated). Axis disclosure: when a publicationDate filter is set (which acts on i2_notice.publication_date via EXISTS), summary.latest_publication_date_range and lotCountsByLatestActivityQuarter are bucketed on i2_lot.latest_publication_date (each lot's most-recent notice rollup). A lot that passed the filter via an early notice can have a later latest_publication_date outside the filter window — that's expected, not a bug. Both fields encode their axis in the name; use them to characterise "when was the latest activity", not "what publication window did I filter on". summary.value carries coverage.lots_with_value / lots_total. Many tenders publish without an estimated_value, so the bare total is a lower bound — always quote the coverage ratio (or note "no value coverage") when summarising; never present total in isolation. topVendors, topBuyers, and coOccurringManufacturers are each capped at limit (default 10, max 100); the breakdown lists are unbounded. The applied cap is echoed in meta.applied_limit, so a list whose length equals applied_limit is likely truncated. coOccurringManufacturers reflects co-occurrence on bundled lots, not "leaders" of a filtered product/manufacturer. When you filter by products (e.g. ["PostgreSQL"]), bundled lots will surface other manufacturers from the same lots (Oracle, Microsoft) — these are also-mentioned, not market leaders for the filtered product. When you filter by manufacturers, those ids are excluded from this list so it shows only the co-occurring others. Read the field as "what else shows up alongside my filter". Tip: when the user names a vendor, product, region, or sector, do NOT put those names in query/searchTerms. First call entity_search to resolve them, then pass the canonical ids/names as structured filters (manufacturers, products, nuts, domain, segment). Reserve query for thematic phrases like "AI" or "cloud migration". When free-text input is provided, the response also carries meta.search_semantics (which DB columns the SQL hit, language handling, OR/AND logic), and may include meta.warnings (your free-text term matched a known product/manufacturer — consider the structured filter) or meta.did_you_mean (zero hits but the term resolves to an entity — retry with the example_filter shown).
org_details
ChatGPTFull organization detail aligned with /organization/[party_id]: metadata, KPI counts, top buyers/vendors/products, recent news, plus aggregated stats — award value split by role as value_summary.buyer (money awarded) and value_summary.winner (money won), procedure / framework / domain breakdowns, active-contract metrics split by role, and the most recent awarded lots split into recent_lots_by_role.buyer (tenders this org ran) vs recent_lots_by_role.winner (wins this org made as a vendor). Report the side that matches the org's role in the user's question, or both when it plays both — a side reading 0 / 0 means no contracts in that role, not no value data for the org. Every value total carries coverage.contracts_with_value / contracts_total; the dataset often lacks contract values, so total is a lower bound — always quote the coverage ratio, never present total in isolation. Use this to look up a party_id to feed into lot_search / market_overview as party: [{ id }].
taxonomy_browse
ChatGPTEnumerate the procurement taxonomy: domains and their segments, each with a lot_count. Call this when you do NOT yet know the domain/segment vocabulary — it returns the full grouped tree so you can ground a request like "what's happening in Beratung?" without guessing keywords. Pass domain: {id|name} to scope to a single domain's segments; omit to enumerate everything. entity_search remains the right tool for fuzzy lookup of a named domain or segment. taxonomy_browse is for enumeration. Round-trip: pass segments[].id to lot_search / market_overview as segment: {id} to scope to a single segment, or pass a domains[].id as domain: {id} to scope to every segment under that domain — both ids round-trip directly into F1 without further translation. No persistent_url (no dedicated UI view).
entity_search
Claudefolder_list
Claudelot_details
Claudelot_incumbents
Claudelot_related
Claudelot_search
Claudemarket_overview
Claudeorg_details
Claudetaxonomy_browse
Claude