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
- 18
- Geography
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Get alerts for Definely
Get updates when Definely’s Discoverability Score or category rank changes.
ChatGPT Plugin Discovery Score
ChatGPT Plugin discovery is coming soon
ChatGPT can surface a Plugin when it matches a user's request.Your Plugin Discovery Score measures how often yours appears.
No spam. Unsubscribe any time.
What discovery looks like
Competing in ChatGPT Contract Lifecycle & Review
View Category18 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 and proofreading job concurrently. 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 Part, Section, Clause, Schedule, DefinedTerm, or other labelled item.), 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 structural type of the matching item (e.g. Clause, DefinedTerm, Undefined, Section, Schedule) Input: - document_id (string, required): the unique identifier of the document - name (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 Part, Section, Clause, Schedule, DefinedTerm, or other labelled item.), 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 structural type of the referenced item (e.g. Clause, Schedule, Listed, Inline, Undefined) This tool is useful for understanding cross-references, checking what a clause depends on, and exploring the context of a provision. Input: - document_id (string, required): the unique identifier of the document - token_hash (string, required): the unique hash identifier of the token whose internal references you want to retrieve
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: - document_id (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 Part, Section, Clause, Schedule, or DefinedTerm. 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 structural type of the referencing token (e.g. Clause, Section, Part, Schedule) 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: - document_id (string, required): the unique identifier of the document - token_hash (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 Part, Section, Clause, Schedule, or DefinedTerm. 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 structural type (e.g. Part, Section, Clause, Schedule) This tool is useful for understanding document structure, locating provisions in context, and navigating where a clause sits within a document. Input: - document_id (string, required): the unique identifier of the document - token_hash (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 tokens. Each token represents a structurally meaningful unit (e.g. Section, Clause, DefinedTerm) and includes: - name: the title of the section or clause - hash ID: a unique identifier for the token - tokenType: the type of structure (e.g. Section, Clause, DefinedTerm) This is useful for analysing document structure and performing gap analysis (e.g. identifying missing clauses compared to another document or precedent). Input: - document_id (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 Part, Section, Clause, Schedule, or DefinedTerm. 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 structural type of the child item (e.g. Clause, Section, Part, Schedule) This tool is useful for breaking down a larger document section into its immediate components and understanding how the document is structured. Input: - document_id (string, required): the unique identifier of the document - token_hash (string, required): the unique hash identifier of the token whose child items you want to retrieve
Use this tool to retrieve defined terms in a contract, together with a unique hash for each occurrence. The tool returns a list of objects, each containing: - name: a defined term, being a capitalised word or phrase that is given a specific meaning in the contract, often in a definitions section or in quoted parenthetical drafting - hash: a unique identifier for that specific occurrence of the defined term within the document The same defined term may appear more than once in the output with different hashes, because each occurrence is listed separately. This tool is useful for reviewing contract terminology, checking consistency of definitions, and retrieving hashes for use in other tools. Input: - document_id (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: - document_id (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 Part, Section, Clause, Schedule, or DefinedTerm. The tool returns Proof issues found within the specified token. Proof issues are drafting or proofreading issues identified by the Proof engine. Each issue includes details such as: - id: the unique identifier of the issue - 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 - resolution: how the issue can be handled - paragraphHash: the unique identifier of the paragraph containing the issue Resolution values include: - Fixable: the issue can be fixed automatically - Reviewable: the issue can be reviewed in the Proof tab and fixed by the user - ManualEdits: the issue has been identified by the proofreading engine and must be fixed manually by the user in the document This tool is useful for reviewing drafting issues within a specific part of a document before finalising or revising it. Input: - document_id (string, required): the unique identifier of the document - token_hash (string, required): the unique hash identifier of the token to inspect for Proof issues
Use this tool to retrieve a summary of all Proof issues identified in a document. The summary is grouped by proofreading feature type and shows issue counts by resolution type. Proof issues are drafting or proofreading issues identified by the Proof engine. The tool returns a structured summary showing issue categories, issue types, descriptions, and counts. For each issue type, the summary may include: - issueDescription: a description of the issue type - count: the total number of issues of that type - countAutoResolvable: the number of Fixable issues - countResolvable: the number of Reviewable issues - countUnresolvable: the number of ManualEdits issues Resolution types include: - Fixable: issues that can be fixed automatically - Reviewable: issues that can be reviewed by the agent, but must be fixed by the user in the Proof tab - ManualEdits: issues identified by the proofreading engine that must be fixed manually by the user in the document 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: - document_id (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 Part, Section, Clause, Schedule, or DefinedTerm. The tool returns the text content 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 you receive 'Document not found in database' error, verify that the document_id is correct. Check that the document was successfully prepared via definely_prepare_document before using this tool. - If you receive an error related to token_hash, the hash may be stale or incorrect. Re-fetch the hash from get_document_table_of_contents or fetch_text_by_item_name. Input: - document_id (string, required): the unique identifier of the document - token_hash (string, required): the unique hash identifier of the token whose text you want to retrieve
How do I improve a ChatGPT Plugin's 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-09-20, Definely competes with Contract Information Extractor, F-AI: Contract Review, Ideals, Ironclad Contracts, Safe2Sign: Contract Risk Check, ScopeLinq, SeedLegals, Syntheia, Youtrust 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.