- Brand
- Definely
- Category
- Operations
- Primary Subcategory
- Contract Lifecycle & Review
Integration details
Description
Definely's MCP server gives AI assistants live, deterministic access to contract structure. Resolve definitions, validate cross‑references, map dependencies, and run structural diffs to see how edits propagate across an agreement. Use it to catch broken links and inconsistencies, explain impacts clearly, and ground legal reasoning in contract topology, not just text.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Contract Lifecycle & Review
- Secondary Subcategories
- None listed
- Brand
- Definely
- Access
- Account required
- First tracked
- 2026-09-19
- Tool count
- 22
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Your score is coming
ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.
What discovery looks like

Get alerts for Definely
Get updates when Definely’s Discoverability Score or category rank changes.
Competing in ChatGPT Contract Lifecycle & Review
View Category22 tools agents can invoke
Fallback for clients without a shell (e.g. ChatGPT) where the Step 2 `curl` upload in `definely_upload_document` cannot be run. Given a dragged-in file's download_url, this fetches the file and uploads it to Definely server-side, returning a fileId; then call `definely_prepare_document` with that fileId. Only use this when you cannot perform the Step 2 curl upload yourself — clients that can run curl must use the standard `definely_upload_document` flow instead. If this returns `retryable: true`, call it again (a fresh download_url will be provided) before giving up.
Open the Definely upload widget so the user can pick a local document to analyze. Use this in ChatGPT whenever the user wants to upload a local file — the curl-based `definely_upload_document` flow cannot run there. The widget registers the file with ChatGPT and calls `definely_ingest_document`, which returns a fileId; then call `definely_prepare_document` with that fileId to start processing.
Required workflow: Step 3 of 3 — call this immediately after the curl upload in Step 2. Do not call any other Definely tool until this completes successfully. Runs the full Definely preparation sequence: a. Submits the rules-based analysis job, then the proofreading job with the RB job's ID. b. Polls the rules-based job until it completes (progress == 100%%). c. Stores the document in the Definely document store (Elasticsearch) once the RB job is done. Workflow: 1. `definely_upload_document` — obtain fileId and pre-signed uploadUrl. 2. Bash curl upload — PUT the file to the uploadUrl. 3. `definely_prepare_document` (this tool) — call with the fileId from Step 1 and the original document_name (including extension, e.g. 'contract.docx') to prepare the document for all further Definely tools.
Required workflow: Step 1 of 3 — call this first for every Definely or contract-related request. Do not call any other Definely tool before this. Obtains a pre-signed S3 uploadUrl and fileId for the document. Proceed to Step 2 then Step 3: Step 2 — Upload the file via Bash: curl -X PUT '<uploadUrl>' --data-binary '@/path/to/file' -H 'Content-Type: <content_type>' Content-Type by extension: .pdf -> application/pdf, .docx -> application/vnd.openxmlformats-officedocument.wordprocessingml.document, .doc -> application/msword, .xml -> application/xml. Step 3 — Call `definely_prepare_document` with the fileId. UX note: Do not surface the uploadUrl, curl command, or fileId to the user. Perform the upload silently and only confirm to the user once all three steps are complete.
Use this tool to find a section, clause, defined term, or other document item by its name. The tool searches the document for tokens whose name matches the text you provide and returns the matching results. This is useful when a document contains cross-references and you want to quickly see the text of the referenced item. The tool returns a list of token objects (a token is a meaningful structural unit in a document, such as a section, clause or defined term), each containing: - name: the name of the matching item - text: the text content of the matching item - hash: the unique identifier of the matching item within the document - tokenType: the kind of matching item: section, clause, definition, undefined_term or other Input: - documentUuid (string, required): the unique identifier of the document - tokenName (string, required): the name of the token to search for
Use this tool to find the sections, clauses, defined terms, and other document items that are referred to within a specific part of a document. The tool looks inside the specified section and returns the document items that are referenced within it. The tool returns a list of token objects (a token is a meaningful structural unit in a document, such as a section, clause or defined term), each containing: - name: the title, label, or term being referenced - text: the full text content of the referenced item - hash: the unique identifier of that referenced item within the document - tokenType: the kind of referenced item: section, clause, definition, undefined_term or other This tool is useful for understanding cross-references, checking what a clause depends on, and exploring the context of a provision. Input: - documentUuid (string, required): the unique identifier of the document - tokenHash (string, required): the unique hash identifier of the token whose internal references you want to retrieve
Use this tool to search the Vault for clauses, definitions, and other document items whose name matches your query. Best for: named clauses or terms (e.g. 'Leakage', 'Change of Control') where you know the exact or partial name. The Vault is the firm's repository of precedent clauses, definitions, and other reusable drafting materials. This tool performs a lexical search, which means it matches exact words or phrases in the item name. It can return results where the name fully matches or partially matches the search term you provide. You can refine the search using metadata filters such as contract type, governing law, parties, authors, document name, token type, and other available filters. The tool returns items (up to 5), total, limit and offset. Each item can include: - name and text: the heading and text of the matching item - tokenType: the kind of item: section, clause, definition or other - documentName, folderName, folderAncestors and tokenAncestors: where the item sits - contractType, jurisdiction, parties, labels and authors: document metadata, as names - isGoldStandard, vaultType, isInsertedManually, insertionCount, isFrequentlyUsed, createdAt and lastModifiedAt Use this tool when you want to retrieve a clause or defined term from the Vault and you already know its name, or at least part of its name. Do not use this tool when you do not need Vault content, when you do not know any exact part of the item name, or when you want to search by meaning rather than exact wording. Tips: - Set primaryDocumentUuid to the fileId of the uploaded document — this surfaces contextually relevant results higher. Without a document, use 00000000-0000-0000-0000-000000000000. - When the user names a specific precedent document, pass documentNames: ["<exact name>"] to scope the search to that document only. - People who drafted, wrote or authored a document go in authors; the companies or individuals that entered into the agreement go in parties. - Vault search returns up to 5 results by default. If the first batch does not include the right result, increase offset to paginate. - The vault contains both Personal (individual lawyer) and Company (firm-wide) documents. Leave vaultTypes empty to search both. Only filter to one type if the user explicitly requests it. - If this lexical search returns no results or off-topic results, follow up with find_similar_items_in_vault using a description of what the clause does as the text parameter. - If the user mentions a specific document name that results do not surface, try find_precedent_in_vault with the document name to locate it directly, then filter subsequent searches by that documentName. Input: - name (string, required): the name or partial name to search for - primaryDocumentUuid (string, required): the fileId of the current document, or 00000000-0000-0000-0000-000000000000 - offset (integer, optional, default 0): the number of results to skip; each call returns up to 5 results - contractTypes, labels, parties, governingLaws, documentNames (list of strings, optional): only search items with these values - authors (list of strings, optional): only search items from documents drafted by these people; several are OR'ed - vaultTypes (list of Personal or Company, optional): leave empty to search both - tokenType (one of All, References, Definitions, Clauses, SubClauses, optional, default All): References are section headings - goldStandardOnly, manuallyAddedOnly, bookmarkedOnly (boolean, optional, default false)
Use this tool to find the Vault document whose name best matches a given name and retrieve its reference report. The Vault is the law firm's repository of precedent contracts, clauses, defined terms, and other reusable drafting materials. A reference report is a structured outline of a document that shows its sections, clauses, and subclauses in a hierarchical view. This gives you a high-level skeleton of the precedent document, making it easier to compare structure, spot missing provisions, and understand how your current document differs from similar precedents. The tool returns: - documentName: the name of the related Vault document - references: the reference report showing the structure of the related document - needsReprocessingForReferences: true when the document must be reprocessed before its references are available If no Vault document matches, the tool returns no content. Tip: Use this tool when the user mentions a specific document name that find_items_by_name_in_vault did not surface — locate it here directly by name, then filter subsequent vault searches by that documentName. Input: - vaultDocumentName (string, required): the name of the Vault document to find - contractTypes, labels, parties, governingLaws (list of strings, optional): only search precedents with these values - vaultTypes (list of Personal or Company, optional): leave empty to search both - goldStandardOnly, bookmarkedOnly (boolean, optional, default false)
Use this tool to search the Vault for clauses, definitions, and other document items that are similar in meaning to your query. Best for: concepts or behaviours (e.g. 'how we cap liability on warranties') — pass a descriptive text to search by meaning. The Vault is the firm's repository of precedent clauses, definitions, and other reusable drafting materials. This tool performs a semantic search, which means it looks for content that is similar in meaning, context, or concept, not just exact wording. Search with a text snippet, and optionally a name. You can also refine the search using offset and metadata filters such as contract type, governing law, parties, authors, document name, token type, and other available filters. The tool returns items (up to 5), total, limit and offset. Each item can include: - name and text: the heading and text of the matching item - tokenType: the kind of item: section, clause, definition or other - documentName, folderName, folderAncestors and tokenAncestors: where the item sits - contractType, jurisdiction, parties, labels and authors: document metadata, as names - isGoldStandard, vaultType, isInsertedManually, insertionCount, isFrequentlyUsed, createdAt and lastModifiedAt Use this tool when you want to find similar provisions based on meaning or wording, or when you are looking for a clause or defined term but do not know its exact name. Do not use this tool when you do not need Vault content, or when you already know the exact name of the clause or defined term and a lexical search would be more appropriate. Tips: - Set primaryDocumentUuid to the fileId of the uploaded document — this surfaces contextually relevant results higher. Without a document, use 00000000-0000-0000-0000-000000000000. - When the user names a specific precedent document, pass documentNames: ["<exact name>"] to scope the search to that document only. - People who drafted, wrote or authored a document go in authors; the companies or individuals that entered into the agreement go in parties. - Vault search returns up to 5 results by default. If the first batch does not include the right result, increase offset to paginate. - The vault contains both Personal (individual lawyer) and Company (firm-wide) documents. Leave vaultTypes empty to search both. Only filter to one type if the user explicitly requests it. Input: - text (string, required): the wording or passage to search by meaning - primaryDocumentUuid (string, required): the fileId of the current document, or 00000000-0000-0000-0000-000000000000 - name (string, optional): the title, label, or term to search for - offset (integer, optional, default 0): the number of results to skip; each call returns up to 5 results - contractTypes, labels, parties, governingLaws, documentNames (list of strings, optional): only search items with these values - authors (list of strings, optional): only search items from documents drafted by these people; several are OR'ed - vaultTypes (list of Personal or Company, optional): leave empty to search both - tokenType (one of All, References, Definitions, Clauses, SubClauses, optional, default All): References are section headings - goldStandardOnly, manuallyAddedOnly, bookmarkedOnly (boolean, optional, default false)
Use this tool to find the most relevant similar document to current document in the Vault and retrieve its reference report. The Vault is the law firm's repository of precedent contracts, clauses, defined terms, and other reusable drafting materials. A reference report is a structured outline of a document that shows its sections, clauses, and subclauses in a hierarchical view. This gives you a high-level skeleton of the precedent document, making it easier to compare structure, spot missing provisions, and understand how your current document differs from similar precedents. The tool returns: - documentName: the name of the related Vault document - references: the reference report showing the structure of the related document - needsReprocessingForReferences: true when the document must be reprocessed before its references are available If no Vault document matches, the tool returns no content. This tool is useful for precedent comparison, gap analysis, and identifying clauses or sections that may be missing from the document you are working on. Input: - documentUuid (string, required): the fileId of the current document, as returned by definely_prepare_document - contractTypes, labels, parties, governingLaws (list of strings, optional): only search precedents with these values - vaultTypes (list of Personal or Company, optional): leave empty to search both - goldStandardOnly, bookmarkedOnly (boolean, optional, default false)
Use this tool to check a piece of text against a contract and identify any undefined terms in that text. You can provide a clause, paragraph, or other body of text. An undefined term is a capitalised word or phrase used in the text that is not defined in the target contract. The tool returns a list of text values, each being one undefined term found in the supplied text. For example, if the text includes a capitalised term such as "Agreement" and that term is not defined in the contract, the tool may return "Agreement". This tool is useful for checking draft wording before inserting it into a contract, helping to avoid ambiguity and unintended undefined terms. Input: - documentUuid (string, required): the unique identifier of the target contract - text (string, required): the text to analyse for undefined terms
Use this tool to find where a section, clause, or other document item is referred to elsewhere in the document. A token is a meaningful structural unit in a document, such as a section, clause or defined term. The tool returns a list of token objects that reference the specified token. Each returned object includes: - name: the title or label of the referencing token - text: the full text content of the referencing token - hash: the unique identifier of the referencing token - tokenType: the kind of referencing token: section, clause, definition, undefined_term or other This tool is useful for finding cross-references, tracing where a clause or section is mentioned, and understanding how provisions connect across a document. Input: - documentUuid (string, required): the unique identifier of the document - tokenHash (string, required): the unique hash identifier of the token whose references you want to retrieve
Returns Definely's design tokens (fonts, colours, spacing, table layout) for rendering Definely-specific outputs. Call this when producing a visual deliverable that should carry Definely's brand — for example, an Issues List report, a Proofread summary widget, or a clause-comparison table derived from Definely tools. Choose the context that matches what you are about to render: - 'General': the top-level Definely design system (fonts, colours, spacing, component patterns). Use this as the baseline for any output not covered by a more specific context. - 'Issues List': design tokens and layout rules specific to the Issues List report. - 'Proofread': design tokens and layout rules specific to the Proofread / Proof widgets. Not required for outputs unrelated to Definely's surface. Input: - context (string, required): one of 'General', 'Issues List', or 'Proofread'
Use this tool to retrieve the section or clause that contains a given token within a document. A token is a meaningful structural unit in a document, such as a section, clause or defined term. The containing section is the immediate higher-level structure in which the token sits. Example: Clause 5 (Payments) 5.1 The Buyer shall pay the Purchase Price on Completion. 5.2 The Purchase Price shall be paid in cash. In this example: - Clause 5 is the containing section - Clause 5.1 and 5.2 are subclauses (child tokens) - The containing section of Clause 5.1 is Clause 5 The tool returns a single token object containing the parent section’s details, including: - name: the title or label of the section - text: the full text content of the section - hash: the unique hash identifier of the section - tokenType: the kind of item: section, clause, definition, undefined_term or other A top-level item has no containing section; the tool then returns an error. This tool is useful for understanding document structure, locating provisions in context, and navigating where a clause sits within a document. Input: - documentUuid (string, required): the unique identifier of the document - tokenHash (string, required): the unique hash identifier of the token
Use this tool to retrieve the table of contents of a document. The table of contents provides a hierarchical outline (tree structure) of the document, listing all sections, clauses, and subclauses. The tool returns a list of nested entries, each containing: - name: the title of the section or clause - hash: a unique identifier for the entry (absent on a grouping heading) - tokenType: the kind of entry: section, clause, definition, undefined_term or other - children: the entries nested under this one (absent on the lowest level) This is useful for analysing document structure and performing gap analysis (e.g. identifying missing clauses compared to another document or precedent). Input: - documentUuid (string, required): the unique identifier of the document
Use this tool to generate and retrieve the Issues List for a document that has already been prepared for analysis. The Issues List is a client-facing report that extracts tracked changes, mark-ups, and comments from a document and presents them as a formatted markdown report. This tool is useful for reviewing edits, sharing a clear change summary with clients, and supporting export workflows. This tool must only be used after definely_prepare_document has completed successfully. It requires a scan_job_id, which is the RB jobId returned in the rb_job field of definely_prepare_document. Output format: - Tracked insertions are wrapped in <ins>...</ins> HTML tags — render these as underlined or visually highlighted text, not as literal tags. - Tracked deletions are wrapped in ~~...~~ markdown strikethrough. - Both must be preserved and rendered when presenting the issues list to the user. Troubleshooting: - If the job fails, verify that scan_job_id comes from a successful definely_prepare_document call (check the rb_job.success field is true). - A failed job may indicate the RB analysis did not complete — check definely_prepare_document returned successfully for this document. Input: - scan_job_id (string, required): the RB jobId returned by definely_prepare_document
Use this tool to retrieve the child items within a specific section, clause, schedule, or other document part. A token is a meaningful structural unit in a document, such as a section, clause or defined term. A child token is a document item that sits directly within the specified token in the document hierarchy. For example, if a section contains clauses 1.1, 1.2, and 1.3, those clauses are the child tokens of that section. The tool returns a list of token objects, each containing: - name: the title or label of the child item - text: the full text content of the child item - hash: the unique identifier of the child item within the document - tokenType: the kind of child item: section, clause, definition, undefined_term or other This tool is useful for breaking down a larger document section into its immediate components and understanding how the document is structured. Input: - documentUuid (string, required): the unique identifier of the document - tokenHash (string, required): the unique hash identifier of the token whose child items you want to retrieve
Use this tool to retrieve the defined terms in a contract. A defined term is a capitalised word or phrase that is given a specific meaning in the contract, often in a definitions section or in quoted parenthetical drafting. The tool returns a list of text values, each containing the name of one defined term. This tool is useful for reviewing contract terminology and checking consistency of definitions. Input: - documentUuid (string, required): the unique identifier of the contract
Use this tool when you need a list of every undefined term in a contract. An undefined term is a capitalised word or phrase that appears to be a defined term but is not given a meaning in the definitions section or elsewhere in the document. Undefined capitalised terms may cause ambiguity and should be defined or written in lowercase. The tool returns a list of text values, each containing one undefined term- only the name of the term, without any additional context. This tool is useful for spotting ambiguity, inconsistent drafting, and missing definitions in contracts. Input: - documentUuid (string, required): the unique identifier of the document
Use this tool to retrieve all Proof issues identified within a specific section, clause, or other document item. A token is a meaningful structural unit in a document, such as a section, clause or defined term. The tool returns Proof issues found within the specified token. Proof issues are drafting or proofreading issues identified by the Proof engine. The result contains: - count: the total number of issues in the token - remaining: the number of issues after this page - issues: up to 200 issues, each with: - type: the category of issue (e.g. MissingCrossReference, DuplicatedTerms, UsedBeforeDefined) - issueText: the text giving rise to the issue - context: a snippet showing where the issue appears This tool is useful for reviewing drafting issues within a specific part of a document before finalising or revising it. Input: - documentUuid (string, required): the unique identifier of the document - tokenHash (string, required): the unique hash identifier of the token to inspect for Proof issues - skip (integer, optional): the number of issues to skip; when remaining is above 0, call again with skip increased by the number of issues returned
Use this tool to retrieve a summary of all Proof issues identified in a document. The summary is grouped by category and then by proofreading feature type, with an issue count for each. Proof issues are drafting or proofreading issues identified by the Proof engine. The result maps each category to its feature types, and each feature type to: - issueDescription: a description of the issue type - count: the total number of issues of that type - groups (optional): for feature types grouped by subject (e.g. by defined term), the number of issues in each group The summary may cover categories such as editing mistakes, drafting notes, definition issues, cross-reference issues, and smart search results. This tool is useful for getting a high-level view of document quality and identifying which categories of issues need the most attention. Input: - documentUuid (string, required): the unique identifier of the document
Use this tool to retrieve the text of a specific document item. A token is a meaningful structural unit in a document, such as a section, clause or defined term. The tool returns the plain text of the specified token. This is useful when you already know the hash of a document item and want to read its wording directly. Troubleshooting: - If the tool returns an error, check documentUuid and check that definely_prepare_document completed. - The tokenHash may be stale or incorrect. Re-fetch it from get_document_table_of_contents or fetch_text_by_item_name. Input: - documentUuid (string, required): the unique identifier of the document - tokenHash (string, required): the unique hash identifier of the token whose text you want to retrieve
Definely ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Definely's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Definely alternatives on ChatGPT?
As of 2026-11-02, Definely competes with AuditTrove, ClauseAI, Contracko, Contract Information Extractor, DUE Brand Deal Commercials, F-AI: Contract Review, Ideals, Ironclad Contracts and 5 more in ChatGPT Contract Lifecycle & Review, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.