add_context
ChatGPTAdds a new context item to the team's reference library: reference material (product facts, positioning, competitor notes, web pages) that Marcora uses to ground AI-generated content. Give a descriptive name, then the body in EXACTLY ONE of three ways (none, or more than one, is rejected): 1) content: paste the markdown body. Best for short or hand-authored material. Creates a plain text item. 2) import_url: a public URL imported ONCE. The page is fetched and converted to clean markdown server-side and stored as a static snapshot that cannot be refreshed. Use it for one-off imports (an exported document link, a competitor's blog post). 3) connected_webpage_url: a URL tracked as a live web page. It is fetched, stored as a "webpage" item, and the URL is remembered so it can be re-pulled later (update_context refresh_webpage, or the refresh button in the app). Use it for the customer's own pages and anything to keep current. If the URL is already tracked, the existing item is UPDATED in place (no duplicate) and its stored content is OVERWRITTEN with the fresh fetch. Requires admin or editor role. Both URL paths wait for the import, up to about 25 seconds. If the page loads in that time the response has import_status "ready" (get_context_item returns the body). If the page can't be read the call returns an error and nothing is added (a tracked page keeps its saved copy). Only a slow page returns import_status "processing" with a real context item id; for what polling shows and how long to wait, see Polling below. Optionally pass collection_id (see list_context_collections / create_context_collection) and/or project_id (see list_projects) to create the item there directly. These apply to all three paths. Present the returned link_url (it opens the new item in the Marcora web app) exactly as returned. Polling after "processing": get_context_item has no import_status. import_url: not found until the import finishes, then the item with its content. connected_webpage_url: the item exists at once with empty content (word_count 0) until the fetch lands; if the fetch fails a new page is removed (not found) and a tracked page keeps its saved copy. Poll for up to about 5 minutes; if the save is still unconfirmed, tell the user it couldn't be confirmed yet and do not re-add the URL yourself (a retry can create a duplicate). A failed slow import sends the user a "wasn't saved" notification. Plan capacity: when the team's plan limits context items, the result includes capacity with used, limit and remaining after this add (a processing import_url counts in that reply but does not reserve the slot: if another add fills it, the import is refused when it finishes and adds nothing; a new web page holds its slot from the start); on a plan with no limit it is absent. At the limit, a call that would create a context item (content, import_url or a new web page) returns an error stating the limit: deleting an item makes room. Re-adding a connected_webpage_url the team already tracks still refreshes it. Extraction: both URL paths use AI main-content extraction: it isolates the primary page or article body and drops navigation and boilerplate. A connected_webpage_url fetch can fail when the page is unreachable or blocks automated requests. Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
apply_grounding_fix
ChatGPTApplies Marcora's recommended fix for one or more findings ("yes, do recommendation <id>"). This WRITES to the user's library or document, so read each finding's suggested_fix and confirm with the user before applying. When to use: the user has reviewed findings from check_content_grounding / get_grounding_result or from list_context_intelligence_findings (including health-audit recommendations from trigger_health_audit_scan) and wants them acted on. You never compose the fix yourself: pass finding_ids, and each finding's stored recommendation is applied. It is the same action as the Apply button in the Marcora UI: same permissions (admin or editor), same billing, same result. Where each fix lands: by default the context item named in that finding's context_item_id; a null context_item_id means the content document itself. Pass context_item_overrides to redirect a specific finding elsewhere (the UI's destination picker). Asynchronous: returns at once with one job per finding. Findings whose fixes land in the same document run together and share a generation_id: poll each distinct generation_id once with get_generation_status. Brand Foundation findings are not grouped. The honest outcome is document_updated there: true means the document changed, false means the recommendation was already covered and nothing was written. Report that distinction; don't assume every applied fix changed something. Partial success is normal: findings that could not start come back in errors[] with a reason while the rest run. Check both jobs[] and errors[]. Serves BOTH families of finding on the shared substrate: content-grounding findings (from a grounding scan) and Context Intelligence health-audit recommendations (from trigger_health_audit_scan). One tool for both. For a shared generation_id, document_updated covers every finding in that run. Errors: - Missing param: finding_ids (400). Pass finding_id values from a prior findings response. - InputError: finding_ids must be finding_id UUIDs (400). - InputError: context_item_overrides names a finding not in finding_ids (400). The override would be ignored, so it is rejected rather than silently dropped. - You are not authorized to perform this action (403). Applying requires an admin or editor role. - This finding is not a content grounding finding / has already been resolved (400). Per finding, surfaced in errors[]. - Marcora is already updating this document. Per finding, surfaced in errors[]: another run on that document (for example the user's own Content Assistant request, or an earlier apply_grounding_fix call) is still in progress. Wait for it to finish, then retry those findings.
ask_content_assistant
ChatGPTSends a natural-language request to Marcora's in-document Content Assistant about ONE EXISTING content document (content_id, from list_content, get_content or get_project). The request can ask for an edit ("tighten paragraph two"), an extension, or pure ideation or a question ("give me three headline ideas"); the assistant decides whether to change the document or only reply. This is the in-editor Content Assistant, not the Marcora Agent. It may rewrite the document body. It only does so when it decides the request warrants a change; otherwise it replies in the document's sidebar thread. Pass chat_only_mode=true to force a reply with no document change. Asynchronous. It returns a generation_id at once and does the work in the background; it does not return the assistant's text. If the user has the document open in Marcora, the reply and any edits stream live into its AI Assistant sidebar. Headless callers poll get_generation_status with the generation_id. One run per document at a time. A second call on the same document while a run is in progress fails with "Marcora is already updating this document." A run that may edit the document also holds it: nobody can edit it in the app until the run finishes or fails. A chat_only_mode=true run doesn't hold it. To send several requests, wait for each run to reach a terminal status, or combine them into one prompt. Never retry in a tight loop. Context: the assistant sees the current document body, the prior sidebar conversation and relevant brand and reference context. Add collection_ids or project_id to fold in more. Inputs: content_id and prompt (required); optional selected_text, thinking_mode, chat_only_mode, ai_provider, collection_ids, project_id. Inputs: - content_id: the content document to act on (from list_content, get_content, or get_project). - prompt: the request, in natural language. - selected_text: optional text the user has highlighted in the document for the request to focus on. - thinking_mode: optional; enable extended reasoning for harder requests. - chat_only_mode: optional; force a reply-only response with no document edit. - ai_provider: optional model family (anthropic default, or openai). - collection_ids: optional Context Collection IDs to include. - project_id: optional project UUID to include its context. Errors: - notfound: content_id matches no content document. - "Marcora is already updating this document.": another run on this document is still in progress. Wait for it to finish (poll get_generation_status if you have its generation_id), then retry.
check_content_grounding
ChatGPTRuns Marcora's content grounding on a piece of content: extracts its factual claims, checks each against the team's context library, and returns which are supported, which conflict with the library, and which are gaps the library can't back up. It checks against the TEAM'S library only, never the open web. When to use: after drafting or revising marketing content, when the user asks to fact-check, verify or ground a document against their own context ("check this against our context", "is this accurate?"), or as the check step in a draft → ground → revise → re-ground loop. Three entry modes (supplying neither field is an error): - content_id alone: scan an existing content item. Use this to check part of an existing document. - content alone: SAVES the markdown as a NEW content item, then scans it. The new content_id comes back. title is optional and only applies here. - content_id + content: ⚠️ REPLACES THAT DOCUMENT'S ENTIRE BODY with the markdown you pass (identical to update_content), then re-scans. Send the FULL revised document, NEVER a fragment: the rest of the document would be destroyed. Timing: a fresh scan typically takes 120-150 seconds. This call waits up to about 20 seconds; if the scan is still running it returns status="running" with a content_id and scan_id. Then POLL get_grounding_result with the scan_id (polling with content_id returns the PREVIOUS completed scan). Do NOT call this tool again for the same scan: it queues redundant work and spends more credits. Re-scanning an unchanged document is fast. Gating: requires the Command plan with an active subscription and available Studio Credits, and an editor role. Full findings go to the content's creator; others get summary counts only (details_visible=false). Present link_url exactly as returned. When title is omitted with content, the name is derived from the first line. Re-scanning an UNCHANGED document takes a few seconds because unchanged claims are reused. The library freshness sweep that runs first is free. Errors: - Provide either 'content_id' or 'content' (400): neither was supplied. - Not a valid UUID (400): malformed content_id. - Context Intelligence requires the Command plan (403): plan/credits gate failed. - You are not authorized to perform this action (403): the token's user lacks an editor role on the team. Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
convert_markdown_to_word_doc
ChatGPTUse this tool to export markdown content as a downloadable Word (.docx) file. Workflow: 1) Use get_content to retrieve the content body (markdown). 2) Pass the markdown_content to this tool. 3) Optionally provide a filename (without extension). 4) Optionally provide document_url to embed a footer link back to the original Marcora content. 5) Returns a download URL for the .docx file. Useful when users need Microsoft Word or Google Docs compatible format. Costs 2 Studio Credits per successful conversion (charged to the user's team; the team must have at least 2 credits or a friendly insufficient-credits error is returned).
create_blueprint
ChatGPTSYNCHRONOUS — takes 1-3 minutes. This is expected; do not retry or assume an error. Use this tool to create a reusable blueprint template for generating content at scale. Blueprints define the structure and AI instructions for a document type. Workflow: 1) Get category_id from list_content_categories. 2) Write content as a markdown template with structure and instructions for the AI. 3) After creating, use the returned blueprint_uuid with create_content (passing it as blueprint_uuid) to generate content. The source_content field should be well-structured markdown with clear sections which represents your template. This is an example of the content you want this blueprint to output. The AI will analyze it and generate reference_content (a polished version), blueprint_dna (template analysis), input_instructions (guidance for users), and a summary. AI analyzes your content and generates multiple supporting fields. If the user wishes to have more control over the creation of the blueprint itself, use the create_blueprint_draft tool instead. This tool will output a link_url for the user to iterate on the blueprint draft with the help of AI before publishing it as a blueprint. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
create_blueprint_draft
ChatGPTUse this tool to create an AI-assisted blueprint DRAFT from a prompt. This creates a draft blueprint template you can review and edit within the Marcora app before saving as a full blueprint. If you already have the full content of the blueprint template you want to make, you should use the create_blueprint tool instead. Only use this tool if you wish to give a prompt to have the AI generate the blueprint template and receive a URL to edit further. Uses Studio Credits (charged when the draft completes, at the model's cost: 1 credit = 5¢, rounded up). If the team is out of credits the call fails with an insufficient_credits error (code 402) and no draft is created. Workflow: 1) Provide instructions describing the blueprint you want to create. 2) Provide a name for the draft. 3) Provide initial markdown content (or empty if you want the AI to generate from the instructions alone). 4) Optionally get category_id from list_content_categories. 5) Review the AI-generated result, then have the user visit the link_url to finalize the blueprint. The returned uuid is the draft's identifier — pass it as draft_uuid to finalize_blueprint_draft. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
create_content
ChatGPTSaves a new piece of content as a document in the user's Marcora workspace. Every successful call creates a new saved document, not a chat reply. By default YOU write the content: call get_relevant_context with include_brand_foundation: true, write the piece from what it returns, then save it here with content. To save text the user already has ("save this exactly as written"), pass it as content unchanged: no context call, and not add_context, which stores reference material, not a document. If the user wants a draft in the chat instead, do not call this tool. To revise an existing document, use update_content (it edits in place; Marcora keeps version history), not a new document. Pick exactly ONE input path. A call with both content and instructions is rejected. - content (the default): saves your markdown VERBATIM, synchronously, and consults NO context, so ground your draft with get_relevant_context first, as above. Cannot be combined with blueprint_uuid. - instructions: Marcora writes it. Use it only when the user asks Marcora to write it, a blueprint is used, or a plan is being fulfilled. It gathers the team's context itself, so on this path do NOT pre-fetch. Quick by default: synchronous, 45 seconds to about 3½ minutes (allow a long timeout); returns the content object. - instructions + generation_mode: "multi_model" (no blueprint): ASYNC; get_generation_status returns the finished document (3-5 minutes). - instructions + blueprint_uuid (from list_blueprints): ASYNC: returns a generation_id; poll get_generation_status until "completed" (3-5 minutes). Title: there is no title parameter. The title is the document's first heading: start content with # <Title>, or state the title in instructions. Present link_url to the user exactly as returned. Building on existing documents: when you are writing it yourself, read them with get_content (find them with list_content) and write from them; reference_content_ids is rejected with content. Referencing existing content when Marcora writes it (`reference_content_ids`): to have Marcora generate WITH REFERENCE to existing documents (a past post to echo, a brief to build on), pass their content UUIDs (from list_content, or list_content with search). The tool resolves each id server-side, pulls its full text and folds it into the generation prompt as reference material, so you do not need to paste document text into instructions. Valid only on the instructions paths (with or without blueprint_uuid); REJECTED with content. Unknown or inaccessible ids fail the whole call, so pass ids you got from a list/get tool. Choosing a path for net-new content: write it yourself from get_relevant_context (with include_brand_foundation: true) and save it with content; this also covers text the user already wrote or approved. Use instructions only when (a) the user asks Marcora to write or generate it, (b) a blueprint is used (the user names one or asks for a template: instructions + blueprint_uuid), or (c) a plan is being fulfilled (produce_plan, or instructions + blueprint_uuid + plan_id). Do not call list_blueprints on every request to look for a template. Title details: the title keeps following the first heading when the document is edited later. With instructions, if the user wants a specific title, say so in the instructions text (e.g. "Title it: Weekly Trends – Sept 16"). Never pass both content and instructions, not even to carry a title. Optional inputs: 1) category_id from list_content_categories. 2) dimension_option_ids from list_targeting_dimensions. 3) collection_ids from list_context_collections. 4) generation_mode ("quick" or "multi_model"; default Multi-model with a blueprint, Quick without), and for Quick only ai_provider ("anthropic" default, or "openai") and use_extended_thinking (default true; slower, can cost more; false for a faster run). All three are instructions paths only; provider and thinking are ignored with Multi-model. 5) `refer…
create_context_collection
ChatGPTCreate a new context collection to organize your reference materials. Collections group related context items together for easier management and targeted retrieval. Parameters: - name: A descriptive name for the collection (e.g., "Brand Guidelines", "Product Research Q2") - description: A short description of what this collection contains - is_private: If true, only you can see this collection. If false, all team members can access it. After creating a collection, use the returned 'id' with the add_context tool (pass it as collection_id) to add context items to this collection. You can also use list_context_collections to see all existing collections and their IDs. The response includes a link_url that opens the new collection directly in the Marcora web app. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
create_external_share
ChatGPTCreates a public share link for content, with optional expiration. Accessible by anyone without a Marcora account. Workflow: 1) Get content_id from list_content. 2) Optionally provide expires_at as a Unix timestamp to limit access duration. 3) Returns a ready-to-use share_link URL that is accessible publicly, but won't be indexed by search engines.
create_plan
ChatGPTCreates a content plan (a planned piece of content: what to write and with which inputs) for the user's active team. It does not write the content: use produce_plan to generate a plan's content, or create_content to write something now. title is the only required field. Before you create: - Dedupe: call list_plans with a project_id filter before creating plans for a project. If a matching plan exists in Accepted or Suggested, offer to update it (update_plan) instead. - Source: "cora_requested" (default) when the user explicitly asked; "cora_proactive" for an unprompted suggestion. Never use "workflow" or "playbook" from an interactive session. What the server decides: - Starting stage is automatic from `source`: cora_requested / playbook → Accepted (actionable now); user_added / cora_proactive / workflow → Suggested (needs the user to accept before it can be produced). - Visibility: "private" (default; the creator's ideas queue, invisible to teammates) or "team". Passing assigned_to for anyone other than the caller auto-promotes the plan to "team", even over an explicit "private". - assigned_to must be the NUMERIC user id of a current team member; emails and names are rejected. - source_metadata is immutable after creation. Useful inputs: prompt (the actual content prompt used when the plan is produced), due_date (YYYY-MM-DD), blueprint_id (UUID from list_blueprints, or integer id), project_id, category_id, reference_document_ids, context_collection_ids, targeting_dimension_ids. When creating several plans in one turn, set source_metadata.batch_id (a client-generated UUID) to correlate them, then link the user to the filtered plans view for that batch. Present link_url exactly as returned. Input roles: - title: required. The one-line summary of the content intent. - description: optional elaboration. Becomes a tooltip in the plans list. - due_date: ISO date YYYY-MM-DD. - prompt: the actual content prompt; pre-populates the content creation form when Generate is clicked. - blueprint_id: blueprint UUID (from list_blueprints) or integer blueprint id. UUIDs are resolved to the internal id server-side; an unknown UUID returns InputError naming list_blueprints. - project_id: project UUID to associate this plan with. - category_id: content category integer ID. - reference_document_ids: array of content UUID strings to associate as reference material. - context_collection_ids: array of integer collection IDs to pre-attach. - targeting_dimension_ids: array of integer dimension option IDs to pre-attach. - source: "cora_requested" | "cora_proactive" | "user_added" | "workflow" | "playbook". - source_metadata: object. Include {cora_session_id, cora_message_snippet} for cora_proactive / cora_requested. For workflow runs use {workflow_template_id, workflow_run_id, workflow_name, run_timestamp}. - assigned_to: optional NUMERIC user id. Defaults to the calling user. - visibility: "private" (default) | "team". Assignment is a communication act, hence the auto-promotion. - plan_uuid: optional client-supplied UUIDv4 for optimistic creates. The server validates format and uniqueness and rejects collisions with InputError; it generates one if omitted. Note: create_plan echoes input reference docs without filtering. If you need the canonical filtered reference_documents array, call get_plan after create. Errors: - InputError: title is required (omitted or empty). - InputError: source must be one of [user_added, cora_proactive, cora_requested, workflow, playbook]. - InputError: plan_uuid already exists (a client-supplied UUID collides with an existing plan in this team). - InputError: invalid plan_uuid format (not a valid UUIDv4). - InputError: assigned_to is not a member of the team. - InputError: assigned_to must be the numeric user id of a team member (a non-numeric value was sent). - InputError: visibility must be one of [private, team]. - AccessDenied: JWT does not resolve to a valid team context. Links: copy link_url character for character. Never retype, shorten, …
create_playbook
ChatGPTCreate a reusable content playbook — an ordered template of content-plan items ("save a repeatable content sequence"). Provide a name and, optionally, the ordered items; each item becomes one content plan when the playbook is instantiated. Visibility: defaults to "team" (visible to all active teammates). Pass visibility "private" to keep it creator-only. Anchor date: if the user is building this playbook around a specific real date (a launch, an event, a campaign kickoff), offer to set anchor_date — it's the reference point every item's offset_days counts from, and it becomes the default when they instantiate. It's optional; leave it off for an evergreen/undated template. The response includes link_url — share it so the user can open the playbook you just created. When to use: when the user wants to author or save a reusable template/playbook of content plans from scratch (e.g. "make me a launch-week playbook", "save this sequence as a template"). To build a playbook from plans the user already ran, use create_playbook_from_plans instead. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
create_playbook_from_plans
ChatGPTCreate a playbook by capturing existing content plans as reusable template items ("save what worked as a template"). Pass the plan UUIDs; their title / description / prompt / blueprint / category are copied into ordered playbook items. Visibility: defaults to "team" (visible to all active teammates). Pass visibility "private" to keep it creator-only. When to use: when the user liked a batch of plans they already produced and wants to reuse that sequence later (e.g. "turn these plans into a playbook", "save this campaign as a template"). To author a playbook from scratch, use create_playbook. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
create_project
ChatGPTUse this tool to create a new project for organizing content and context into a workstream. Projects group related documents and can include project-specific context items. Workflow: 1) Provide a name for the project. 2) Optionally set visibility to "team" or "private" (default: team). 3) Optionally create a project brief at the same time — two ways: - project_brief_content: supply the FINISHED brief text directly. It is saved as the project brief document as-is. NO Studio Credits used. - project_brief_instructions: supply a PROMPT describing the brief; the AI generates the brief document for you. Uses Studio Credits (charged when the brief completes, at the model's cost: 1 credit = 5¢, rounded up; typically 1-2) — if the team is out of credits this returns an insufficient_credits error (code 402) and the project is NOT created; pass project_brief_content instead. If both are supplied, project_brief_content wins (no AI). When a brief is created, the response includes a project_brief object containing the brief's content_id — use that with update_content / get_content later. 4) Use the returned project_id with create_content to associate new content with this project. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
finalize_blueprint_draft
ChatGPTSYNCHRONOUS — takes 1-3 minutes. This is expected; do not retry or assume an error. Use this tool to finalize (publish) a previously created blueprint draft into a full, usable blueprint. This is the final step in the draft workflow: 1) create_blueprint_draft — generates an AI-assisted draft the user can review/edit in the app 2) User reviews the draft at the link_url 3) finalize_blueprint_draft — converts the reviewed draft into a real blueprint After finalizing, use the returned blueprint_uuid with create_content (passing it as blueprint_uuid) to generate content from this blueprint. If you don't need the review step, use create_blueprint instead to create a blueprint directly. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
get_blueprint
ChatGPTRetrieves the full details of a specific blueprint by its UUID. Returns the blueprint's content, AI-generated analysis, and metadata. Use list_blueprints to list all available blueprints and find the blueprint_uuid.
get_brand_foundation
ChatGPTReturns the team's Brand Foundation: the foundational brand and company information that guides all AI-generated content. Read-only. Four elements: - company_overview: general information about the company - brand_voice: tone, core values, mission and personality - writing_style: language complexity, sentence structure, formatting preferences, CTA style - writing_examples: sample content showing the team's distinctive voice (free-form; users organize it however they like) When to use: whenever the user asks about, or wants you to use, their brand voice, company overview, writing style or writing examples. For example: - "What is our brand voice?" / "What is the brand voice of <company>?" - "Summarize our company overview" - "What's our writing style?" / "Show me our writing examples" These four elements live ONLY here. get_relevant_context's relevancy search does not return them, so don't reconstruct the answer from it or from web pages. (get_relevant_context with include_brand_foundation: true bundles them with relevant context when you are writing.) Returns all four elements by default; pass elements to scope the response to a subset. An element the team has not filled out yet comes back as an empty string. When you write content yourself, get_relevant_context with include_brand_foundation: true returns Brand Foundation together with relevant context in one call. You don't need to call this before create_content with instructions or before create_plan: those pull Brand Foundation in automatically. To change an element, use update_brand_foundation. Present link_url (it opens the Brand Foundation section in the Marcora web app) exactly as returned. The response is structured JSON: paste it directly into a downstream AI prompt, or template the fields into markdown. Copy link_url character for character; never retype, shorten, or rebuild a link or the IDs inside it.
get_content
ChatGPTRetrieves the full markdown body of a specific content document by its content_id (UUID). Always warranted: reading a project's BRIEF. When get_project or get_relevant_context returns a project_brief block with truncated: true, call this tool with that content_id before drafting, revising, assessing or critiquing anything in that project. The brief states the premise and the structural decisions already taken, and work produced without it is likely to contradict them. The caution below does not apply to it. Otherwise, use this ONLY when you need to read the content body to answer the user's question — for example: "summarize what my latest case study says about pricing," "what's the main argument in my Q3 launch blog?", or "does this messaging doc mention HIPAA?". The user already has access to view the content in Marcora via its link, so reading the body yourself is only useful when you need to answer something specific about it. Do NOT call this after `create_content` (or after `get_generation_status` returns "completed") just to "show the user what was generated." The user opens the content in Marcora via the link_url — they review it themselves. Marcora hands them the link; the user does the reading. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
get_context_intelligence_finding
ChatGPTFetch one Context Intelligence finding in full detail by its UUID (from list_context_intelligence_findings). When to use: the user wants the specifics of a finding — the full recommendation, the suggested fix content, or which context items it involves — before deciding to act on it. The suggested_fix object (when present) contains the proposed replacement content; applying it is done in the Marcora web app (or via update_context_intelligence_finding_status to acknowledge/dismiss/resolve without applying). Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
get_context_item
ChatGPTOpens a single context item by ID and returns its full markdown content and metadata. Use it when you already have an item's ID and need to read the whole item — list_context_items returns only content_intro (a short truncation), and get_relevant_context returns matched passages. The ID can come from list_context_items, get_project(project_id).context_items, or the sources of get_relevant_context. It does not search; to find material relevant to a question, use get_relevant_context. Authorization: the item must belong to your team. Items in private collections (where you are not the creator) and items in private projects (where you are not a member) return 404 — same as items that do not exist. For web-page items (content_type "webpage"), source_url is the page's tracked URL — pass it back to add_context connected_webpage_url, or call update_context refresh_webpage to re-pull it. It is null for non-webpage items. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
get_current_user_info
ChatGPTReturns profile and subscription information for the currently authenticated user. Use this to personalize responses, check the user's active team, or confirm subscription limits before creating content. Key fields: - active_team_name / active_team_role: current working team context - subscription_status + plan_name: confirms what features are available - ai_credits_available / ai_credits_max: Studio Credits remaining and the plan's limit for the current billing period
get_generation_status
ChatGPTChecks the status of an async generation by generation_id. Read-only. These flows return a generation_id you can poll here: - create_content with a blueprint_uuid or generation_mode: "multi_model" (document generation), and produce_plan; - ask_content_assistant (the in-document Content Assistant); - apply_grounding_fix (each job in jobs[]; jobs whose fixes land in the same document share one generation_id, so poll each distinct id once). The response always includes status, generation_id and flow_type, plus generation_mode ("quick" or "multi_model") when known. content is null until the run finishes: keep polling. Document generation (flow_type != "ai_assistant"): finishes at status "completed". content = { content_id, name, link_url } (plus blueprint_id with a blueprint). Give link_url to the user to review in Marcora; you don't need get_content unless they later ask about the body. Content Assistant flow (flow_type == "ai_assistant", also used by apply_grounding_fix): finishes at status "complete". content = { content_id, name, link_url, assistant_summary, document_updated, current_content }. document_updated says whether the most recent interaction changed the document body (false for a reply-only run, or a grounding fix that was already covered). status tracks THIS run; content is the document's LIVE current state (including the user's own later edits and the most recent assistant interaction), not a frozen snapshot of this run. Statuses: pending, processing, streaming, complete (Content Assistant) / completed (blueprint), failed. Present link_url exactly as returned. Content fields: - assistant_summary: the most recent assistant reply shown in the document's sidebar thread. - document_updated: whether that most recent interaction changed the document body. For a shared generation_id from apply_grounding_fix, it covers every finding in that run. - current_content: the document's current markdown. Returning the live document is deliberate: a stale snapshot isn't useful, the current version is. When the user has the document open in Marcora, the reply and any edits already streamed in live via the realtime channel; polling here is for headless callers, or to retrieve the current document and latest reply text. Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
get_grounding_result
ChatGPTRead the result of a content grounding scan started by check_content_grounding — the poll companion to it. When to use: check_content_grounding returned status="running" (its ~20s inline wait elapsed before the scan finished). Poll this with the scan_id it gave you, roughly every 15-30 seconds; a fresh scan usually completes within 120-150 seconds. Do NOT call check_content_grounding again — that starts a second scan and charges again. Which id to pass: - scan_id — reads that exact scan. This is what you want when polling: it always reports the run you started, whatever its status. - content_id (no scan_id) — reads the latest COMPLETED grounding for that document. Use it to ask "what is this document's grounding state right now" without starting a scan. It deliberately skips a scan that is still running, so it is NOT the right call for polling — you would get the previous result back marked complete. It never starts a scan and never charges credits — it returns immediately with whatever the current state is. The response envelope is identical to check_content_grounding's, so the same handling works for both. Errors: - Provide 'scan_id' or 'content_id' (400) — one of them is required. - Not a valid UUID (400) — malformed scan_id or content_id. - Scan not found (404) — no such grounding scan in your team. - Content not found (404) — no such content in your team. - scan_id and content_id refer to different content (400) — pass scan_id alone. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
get_plan
ChatGPTFetch a single plan by UUID including all linked parameters and metadata. Input roles: - plan_uuid: The UUID string from a create_plan response or a list_plans result. Use plan_uuid, not the integer id. Usage patterns: - Always call get_plan before update_plan to read current state and avoid overwriting fields with stale values. - Use _produced_content to determine whether the plan has linked content (null = no content yet). - Use _source_metadata_resolved for tooltip / inline attribution display without extra lookups. - Before calling create_content with plan_id, verify the plan is NOT in Complete stage. If stage = Complete, ask the user whether to re-open the plan (update_plan target_stage: 'Accepted') before generating again. - reference_documents is filtered to documents readable by the current user — do not assume the full list is returned if the team has cross-team sharing enabled. Errors: - NotFound — plan_uuid doesn't exist or is not visible to you. Cross-team plans return NotFound, not AccessDenied. A teammate's PRIVATE plan (visibility='private', you are neither creator nor assignee) also returns NotFound — do not retry. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
get_playbook
ChatGPTFetch one content playbook by id, including its full ordered list of items. When to use: to inspect a playbook before instantiating or editing it, or when the user asks about the contents of a specific saved playbook/template. NotFound also covers a teammate's PRIVATE playbook (visibility='private', caller is not the creator) — do not retry. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
get_project
ChatGPTReturns details for a specific project: its members, documents, context items, and — when one is set — the project's brief. Read the brief before doing substantive work in this project. The project_brief block is the project's authoritative statement of premise, scope and the structural decisions already taken. Its content_intro is an excerpt (the full body when the brief is short, otherwise the opening ~400 words with truncated: true); call get_content with its content_id for the full text. The other documents and context items in this project may be older than the brief, or may contradict it — the brief wins. Work produced without reading it is likely to contradict decisions already made. The matching entry in documents is flagged is_project_brief: true and sorted first. Use list_projects to discover available projects and find the project_id. project_brief.content_id also doubles as the shortcut for EDITING the brief via update_content.
get_relevant_context
ChatGPTSearches the team's Marcora context library and returns up to 10 passages most relevant to a prompt, plus sources (each with a link_url) for citing. Read-only. When to use: - The user wants writing grounded in their team's brand or company context (a blog post, email, social post, landing page, press release, ad or messaging): call this with include_brand_foundation: true and write it yourself from what it returns. If asked to save it, use create_content content. - The user asks about their own company, product, positioning, launches or competitors ("what do we have on competitor X?"): call it and answer from their context. - Before saving text you wrote yourself through create_content / update_content content: those store it verbatim and consult no context. When NOT to use: - Before create_content with instructions (the Marcora-writes path): Marcora gathers the context itself. - For brand voice, company overview, writing style or writing examples on their own: relevancy search never returns Brand Foundation. Use get_brand_foundation, or set include_brand_foundation: true here. Inputs: - prompt (required): what you need; specific prompts return better chunks. - include_brand_foundation: true on the FIRST call of a conversation (adds company overview, brand voice, writing style and writing examples); false or omitted afterwards. - project_id: adds that project's items and, on the first call, returns its project_brief. Read the brief before drafting: it outranks older chunks. Set include_project_brief: false on later calls for the same project. - collection_ids and project_id broaden the search (additive, never an exclusive filter); dimension_option_ids biases toward an audience, persona or industry; context_rag_ids excludes chunks already returned when you page for more. Present each link_url exactly as returned. How results are ranked: each passage is scored on its own and against the whole document it belongs to, and the two scores are blended; weak matches are dropped, so fewer than 10 can come back. dimension_option_ids lean the ranking toward the chosen audience, persona or industry. It searches the reference library plus the project, collections and shared collections the user can access. Sources: each sources entry carries the item name, content_type, a link_url deep-link that opens the item in the Marcora web app (plus source_url, the original external page URL, for webpage items), its collection_id / project_id / last_updated, and the context_rag_ids from that item. Use these to cite or link the material you surface. (The previous top-level context_item_ids field has been replaced by sources; each source's context_item_id gives you the same IDs.) Project brief: with project_id, the response carries a top-level project_brief block: the project's authoritative statement of premise, scope and the structural decisions already taken. It is the same block get_project returns (content_id, name, word_count, content_intro, truncated, read_first). Read it before drafting, revising, assessing or critiquing anything in the project; context chunks may be older than the brief or contradict it, and the brief wins. When truncated is true, content_intro is only the opening excerpt, so call get_content with its content_id for the full text. The brief is stored as content, not as a context item, so relevancy search never surfaces it: this block is the only way it reaches you from this tool. The key is absent when the project has no brief. include_project_brief defaults to true and is ignored without project_id. Brand Foundation bundling: include_brand_foundation: true returns the team's Brand Foundation (company overview, brand voice, writing style, writing examples) in the same response. It is the always-on foundational context relevancy scoring never surfaces on its own. Pull it once, up front, so you have it for the rest of the session; you don't need it when handing off to create_content with instructions, which pulls…
get_team_info
ChatGPTALWAYS use this when the user asks what team accounts they have, which teams they belong to / are on, or wants to switch teams — do NOT answer from memory or session context, which knows ONLY the single currently-active team and will undercount (a user can belong to many teams). This tool is the only way to enumerate the full list. Returns every team you belong to, each with its full member roster. Read-only. Also use this BEFORE assigning a plan or content to a teammate (to look up their numeric user_id — the value update_plan.assigned_to / create_plan.assigned_to expect), or to answer questions about the team's members and your role. Each team includes: team_id, team_name, is_active (exactly one team is your active team — see set_active_team to change it), your_role, and members[]. Each member has: user_id (the numeric id assignment expects; null for a pending invite that hasn't been accepted), name, email, role, and status ("active" or "invited"). Deliberately does NOT include credits or subscription info — call get_current_user_info for those.
instantiate_playbook
ChatGPTRun a playbook: create one content plan per playbook item, in order, as a batch. Plans land in the Accepted stage with source "playbook" and INHERIT the playbook's visibility (team playbook → team plans; private playbook → private plans). Optionally anchor due dates to a date (each item's offset_days is applied to anchor_date; defaults to the playbook's saved anchor_date if it has one) and/or scope the batch to a project. The response groups the plans under a new CYCLE — use run.link_url to hand the user "here's your cycle" and each plan's link_url for the individual pieces. When to use: when the user wants to actually deploy / kick off / run a saved playbook into real content plans (e.g. "run my launch playbook", "instantiate this template anchored to next Monday"). This is a distinct bulk action — it does NOT create or edit the playbook itself. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
invite_user
ChatGPTInvite someone to your Marcora account by email. An invitation email is sent automatically, and the response also returns the exact invite link (invite_link) so you can share it directly — e.g. paste it to the person in Slack. Roles: - "creator" — a full team member who can create and edit content. - "admin" — a team administrator. - "collaborator" — a project-scoped collaborator who only works inside a specific project. Who can invite whom: - You must be an ADMIN to invite someone as an "admin" or a "creator". Admins can invite any role. - A "creator" can invite "collaborator"s only. - Viewers cannot invite anyone. project_id (a project UUID from list_projects): - REQUIRED when role is "collaborator" — it is the project they will collaborate on. - OPTIONAL for "creator" and "admin". It does NOT limit their access (creators and admins keep full team access); it simply also adds them to that project and makes their invite link drop them straight into it on first sign-in. The invitee is emailed automatically: brand-new users get a sign-up link (returned in invite_link); existing users who still belong to an active team get a login link and will see the invitation in-app after they log in; existing users with no active team (e.g. a removed teammate) get a sign-up link to rejoin with their existing password. The call fails if the email is already an active team member (with no project to add them to), already has a pending invitation, or if you lack permission for the requested role.
learn_marcora_tools
ChatGPTReturns Marcora's guide to its own tools: what each Marcora object is, which tool fits which request, the order the tools chain in, and the mistakes to avoid. When to use this tool: call it once before multi-step Marcora work the user has asked for — for example generating content into a project, setting a project brief, adding reference context, or producing a content plan — or whenever you are unsure which Marcora tool fits a request or how two of them chain. If the Marcora skill is already loaded in your context, you don't need this tool: it holds the same guidance. Called with no topic, it returns an overview (the object model, the context model, a which-tool table) and the list of topics, each with a one-line summary. Call it again with topic for the one section the task needs; don't fetch every topic. Read-only: it reads no workspace data, changes nothing, and uses no credits.
list_blueprints
ChatGPTGet all blueprints in your team's library as a flat list. Each blueprint includes its content category. Use the returned blueprint_uuid with create_content (passing it as blueprint_uuid) to generate content.
list_content
ChatGPTLists the team's content (documents the team has created, from scratch or from blueprints) that the current user can see, as a single unified array with consistent field names, newest first. Use it to browse and filter the team's content and to find content IDs. Use content_id with get_content to retrieve a piece in full. Use create_external_share to share content externally. Optional `search`: pass a natural-language query to sort the list by similarity to it instead of recency. Each row then carries a relevance_score (cosine 0–1, higher = more similar). Search only re-orders: every visible row is still returned, with no cutoff, so the response is as large as the team's content. Scores are comparable with list_context_items. To find passages in the reference library that are relevant to a question, use get_relevant_context.
list_content_categories
ChatGPTReturns all content categories available to your team. Categories organize blueprints and content by type (e.g. GTM Messaging, Website & Blog, Sales & Partner Materials). Use the 'id' as the category_id when creating blueprints (create_blueprint) or content (create_content).
list_context_collections
ChatGPTReturns all context collections accessible to the current user. Collections organize reference materials (context items) that inform AI-generated content. Use the 'id' with add_context to add items to a specific collection, or pass collection_ids to get_relevant_context for targeted context retrieval. Each item includes a link_url that opens the collection directly in the Marcora web app. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
list_context_intelligence_findings
ChatGPTList Context Intelligence findings for the team — issues Marcora's automated scans detected in the team's reference/context library (stale content, contradictions, outdated web sources, classification gaps). When to use: the user asks about their context health, what Context Intelligence found, open findings, or what needs attention in their reference library. Also the right first call before updating any finding's status. Findings are returned newest-first. Each has a status lifecycle: pending (new, needs review) → acknowledged / dismissed / resolved. Filters (all optional): - status: "pending" | "acknowledged" | "dismissed" | "resolved". Use "pending" for the actionable queue. - severity: finding severity as recorded by the scan (e.g. "high", "medium", "low"). - process_type: which scan produced it — "health_audit" (library-wide sweep) | "web_freshness" (tracked webpage changes). - page / per_page: pagination. Default per_page=20, max=100. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
list_context_items
ChatGPTLists the context items in the team's reference library, newest first. Use it to browse and filter the library and to find context-item IDs. By default returns ALL context items the user can see (across projects, collections, and the reference library). Set reference_library_only=true to return only items that are NOT in any project or collection — these are the items shown in the "Reference Library" section of the Marcora web app. Each returned item carries its own collection_id and project_id (both nullable), a short content_intro, and a link_url that opens it directly in the Marcora web app. To get the full markdown content of an item, pass its id to get_context_item. For web-page items (content_type "webpage"), source_url is the page's tracked URL — useful for spotting which items can be refreshed (update_context refresh_webpage). It is null for non-webpage items. Optional `search`: pass a natural-language query to sort the list by similarity instead of recency. Each item is scored by its best-matching passage and carries a relevance_score (cosine 0–1, higher = more similar); items with no indexed passages yet have a null score and sort last. Search only re-orders: every item you can see is still returned, with no cutoff, so the response is as large as the library. To find the passages that are relevant to a question, use get_relevant_context, which returns the top passages with their sources. Privacy: items in private collections (where you are not the creator) and items in private projects (where you are not a member) are filtered out — they will not appear in the response. Other ways to discover context-item IDs: - get_project(project_id).context_items — items attached to a specific project. - get_relevant_context — returns a sources array with the parent context items of matched passages. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
list_plans
ChatGPTLists content plans for the user's active team as paginated summary rows; use get_plan for full detail. Read-only. Use it to find plans to act on and to dedupe before create_plan. Results are visibility-scoped: team-visible plans plus the caller's own private plans (as creator or assignee). A teammate's private plans never appear, so an empty result does not mean the team has no plans. Filters: - stage: array of Suggested, Accepted, In_Process (underscore form), Complete, Dismissed. Omit for all stages. - source: array of user_added, cora_proactive, cora_requested, workflow, playbook. - project_id (project UUID), category_id (integer). - assignee_scope: "me" (default) | "created_by_me" | "all_visible" (team-visible plus your own private ones). - sort: "due_asc_nulls_last" (default) | "created_desc". - page / per_page: default 20, max 100. ⚠️ Known limitations (accepted but not applied yet): due_before, due_after and search_text do not filter; for multi-value stage / source arrays only the FIRST element is honored, so pass single-value arrays. Common uses: - Dedupe before create: filter by project_id; if a matching plan is Accepted or Suggested, offer to update it instead of creating a duplicate. - Workflow suggestions awaiting review: source=["workflow"] + stage=["Suggested"]. - Plans I created: assignee_scope="created_by_me". Present link_url exactly as returned. Upcoming week view (once the date filters apply): due_before = (today + 7 days, YYYY-MM-DD), sort = "due_asc_nulls_last". due_before / due_after take ISO date strings (YYYY-MM-DD). Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
list_playbooks
ChatGPTList all content playbooks visible to the caller in the current team: team-visible playbooks plus the caller's own private ones (a teammate's private playbooks never appear). Playbooks are reusable, ordered templates of content-plan items. When to use: whenever the user wants to see, pick from, or manage their saved playbooks / templates (e.g. "what playbooks do I have", "show my templates"), and before instantiate_playbook / update_playbook to find the right id. Returns summaries only — call get_playbook for a playbook's items. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
list_projects
ChatGPTReturns all projects visible to the current user. Projects organize content into workstreams. Use the 'id' with get_project to retrieve project details, or pass project_id when creating content to associate it with a project. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
list_targeting_dimensions
ChatGPTReturns targeting dimensions and their options for the current team. Dimensions are categories (e.g. Buying Stage, Persona) with selectable options used to target content generation. Pass dimension option IDs as dimension_option_ids when calling create_content to generate content targeted to specific audiences or stages.
produce_plan
ChatGPTProduces (generates) the content a plan describes: the MCP equivalent of the plans board's Generate button. It writes a new document, saved to the user's Marcora workspace and linked to the plan. When to use: the user asks to generate, produce or create the content for an existing plan ("produce that plan"). To create a NEW plan use create_plan; to edit plan fields use update_plan. ⚠️ Credits and duration: it uses team Studio Credits (charged at completion, cost-based: typically Quick 1-2, Multi-model 6-7) and takes 1-5 minutes. Too few credits (Quick needs 1, Multi-model 5) fails with insufficient_credits (402), nothing generated. Confirm with the user before producing a plan they didn't explicitly ask to produce. Mode (optional, omit for defaults): generation_mode "quick" (one model) or "multi_model" (two drafts plus a synthesis); default Multi-model with a blueprint, Quick without. Quick only: ai_provider ("anthropic" default, "openai") and use_extended_thinking (default true; slower, costlier); ignored with Multi-model. Requirements: the plan must be "Accepted". A Suggested plan needs update_plan { target_stage: "Accepted" } first; In_Process / Complete plans already have content (produced_content_id). The plan's prompt, targeting dimensions, context collections and project are used automatically, so set them with update_plan BEFORE producing. Asynchronous on both paths, chosen from the plan: it returns at once with path ("blueprint" or "freeform") and a generation_id. Poll get_generation_status. On completion the plan moves to In_Process (produced_content_id set); the content reaching ready moves it to Complete. Errors: Missing param: plan_uuid; NotFound; InputError: plan is in stage {stage}; invalid mode, provider or thinking value. Present link_url exactly as returned; never retype, shorten, or rebuild a link.
set_active_team
ChatGPTSet your active team — the team all subsequent Marcora tool calls operate against. Input: team_id (the numeric id from get_team_info). ⚠️ GLOBAL EFFECT: switching your active team changes it EVERYWHERE for your account — open Marcora app tabs, any running Marcora sessions, and every other connected MCP client — because it writes the same active-team setting the in-app team switcher uses. Tell the user before you switch, and do NOT switch while other work is mid-flight for them. The response includes previous_team_id so you can restore their original team when you're done: switch → do the work → set_active_team back to previous_team_id. Rejects a team you don't belong to with a readable error (use get_team_info to see your teams).
trigger_health_audit_scan
ChatGPTStart a Context Intelligence health audit — a library-wide AI sweep of the team's context/reference items that produces findings (stale content, contradictions, gaps) reviewable via list_context_intelligence_findings. When to use: the user explicitly asks to check/audit their context health ("run a health check on our context", "scan the library"). Do NOT trigger one unprompted — always confirm first. ⚠️ Cost + gating: the scan consumes team Studio Credits and is gated — it requires the Command plan (active subscription) with at least 50 credits remaining, only one health audit can run at a time, and a cooldown applies after each completed run (the error message tells you when it can run again). Starting a new audit CLEARS the previous health-audit findings. The scan runs in the background; the response returns immediately with a scan_run_id. Findings land as the scan progresses — check list_context_intelligence_findings afterwards. Errors: - ci_not_eligible (403) — plan/subscription/credits gate failed (JSON error body with reason + credit numbers). - A health check is already running. Please wait for it to finish. - Health check ran recently. You can run it again in about {time}.
update_brand_foundation
ChatGPTOverwrites one of the team's four Brand Foundation elements with new content. Always full-replace — no patch semantics. Before calling this tool, you should typically call `get_brand_foundation({elements: ["<element>"]})` first to read the current value so the user can confirm what's being replaced. Brand Foundation content shapes every AI-generated piece of content the team produces, so unintended overwrites are costly. Elements and limits: - company_overview — general information about the company (max 10,000 chars) - brand_voice — tone, core values, mission, personality (max 20,000 chars) - writing_style — language complexity, sentence structure, formatting preferences, CTA style (max 20,000 chars) - writing_examples — sample content demonstrating the team's distinctive voice (max 20,000 chars). Free-form — organize however the user likes. Pass the new content as markdown. Existing content for the element is replaced in full. Other elements are untouched. If the team has no row for the element yet, one is created. Returns the updated element name and content, plus a link_url that opens the Brand Foundation section in the Marcora web app. When you point the user at their updated Brand Foundation, use that link_url exactly as returned — do not construct a Brand Foundation URL yourself; a hand-built one will 404. To re-read the team's full Brand Foundation, call get_brand_foundation. Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
update_content
ChatGPTUpdates an existing content document (by content_id) in place. Use it to revise a document rather than creating a new one; Marcora keeps a full version history and the user can revert any change from the app. Only the fields you supply change, and at least one must be supplied. Fields: content (markdown body), name_override, stage, visibility, category_id, project_id, plus change_summary. `content` REPLACES the entire body verbatim (there is no patch mode), and this tool consults no Brand Foundation or Reference Library. So when you write or rewrite the body: call get_content to read the current body AND get_relevant_context with include_brand_foundation: true, then send the FULL new body. Skip both when you only change non-body fields. Side effects to know: - stage: "ready" on a document linked to a plan also moves the plan to Complete. - name_override locks a custom name permanently; this tool cannot unlock it. Without it, the name follows the first heading. - project_id replaces the document's single project association (no way to remove it from all projects here). - visibility "team" → "private" revokes team-wide access on the next read. Pass `change_summary` on every call: what you changed and why, as skimmable markdown (one line for a small edit; a short bulleted list for several). It is shown in the document's history sidebar. Needs write access: a non-viewer team member who created the document, or the document is team-visible. Present link_url exactly as returned. Name behavior: by default a document's name auto-syncs from the first markdown header in its body. Set name_override to lock a custom name; once locked, the title stays even when the body is edited. Omit name_override to leave the lock state as-is. Stage: in_progress or ready. Setting stage writes both the stage enum and the is_ready bool in lockstep. The plan side effect on ready is non-blocking on failure. Visibility: private (only the creator and project members can see it) or team (anyone on the team). Category: category_id from list_content_categories. Works for all content documents. A category from another team errors. Project association: if the document is already in a different project, the old association is replaced; if it is already in the supplied project, this is a no-op. Omit project_id to leave the association untouched. Use the Marcora app to remove a document from all projects. Change summary format: a single line for one small edit (e.g. "Tightened the closing CTA"); for several distinct edits, a short bulleted list where each bullet is a bold 2–5 word lead, a colon, then the detail. Match length to substance. Blank/omitted logs a generic "Content updated via MCP." and the history becomes useless after a few edits. Authorization: you must be a non-viewer member of the team that owns the document, AND either (a) you created the document, or (b) the document is team-visible. Foreign-team or insufficient-role calls return access denied. Errors: - notfound: content_id doesn't match any content document. - inputerror: no mutable field supplied; invalid category_id; invalid project_id; the document is a non-editable document type (e.g. a context-item editor document). - accessdenied: you don't have write access to the document. Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
update_context
ChatGPTUpdates an existing context item in the team's reference library: rename it, replace its body, re-pull a tracked web page, or move it between collections and projects. ⚠️ Placement is full-replace, not a patch. Call `get_context_item` first and echo its `collection_id` and `project_id` back on every call unless you mean to change them. - collection_id is REQUIRED (the key must be present; omitting it is a 400). Pass the current id to keep the item where it is, a different id to move it, or null (or 0) to move it to the loose reference library. - project_id has NO "leave unchanged" option: omitting it writes NULL and silently DETACHES the item from its project (the call still returns 200). Pass the current value to keep it; pass null only to detach on purpose. Body and name (patch-style; omit to leave alone): - name: new name. - content: new markdown body; triggers re-embedding. - import_url: a public URL fetched once and converted to markdown server-side, replacing the body with a one-off snapshot. Use it instead of content for a large new body. content and import_url are mutually exclusive. refresh_webpage: true re-pulls a tracked web page from its stored URL (the app's refresh button). Valid only for items added with add_context connected_webpage_url (content_type "webpage"); requires admin or editor role. On that branch name / content / import_url are ignored, collection_id is not required, and the item's project and collection stay exactly as they were. Find ids with list_context_items, list_context_collections, get_project or get_relevant_context. Present link_url exactly as returned. Input semantics: - context_item_id: REQUIRED. The UUID of the context item to update. - refresh_webpage: OPTIONAL boolean. On any item other than a "webpage" item it returns a clear error. - name: OPTIONAL. Ignored when refresh_webpage is true. - content: OPTIONAL. Ignored when refresh_webpage is true. - import_url: OPTIONAL. Uses AI main-content extraction (the same engine as connected_webpage_url: it isolates the primary page/article body and drops nav and boilerplate). It is a one-off snapshot; to keep a web-page item in sync with its URL, use refresh_webpage instead. Ignored when refresh_webpage is true. - collection_id: REQUIRED (its value may be null). - project_id: OPTIONAL to send, and DANGEROUS to omit (see above). To KEEP the item in its project you MUST know its current project_id (get_context_item) and pass that value back, every single call. If the context item has a linked editor document, its title, content and word_count are auto-synced and a realtime update is broadcast to open editors. Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
update_context_intelligence_finding_status
ChatGPTUpdate the status of a Context Intelligence finding — acknowledge it, dismiss it, or mark it resolved. When to use: the user has reviewed a finding (via list_context_intelligence_findings / get_context_intelligence_finding) and tells you their decision: "dismiss that one", "mark it handled", "acknowledge it for now". Status meanings: - acknowledged: seen, kept on the radar (still open). - dismissed: not relevant / won't fix — removes it from the actionable queue. - resolved: the underlying issue was fixed (records who resolved it and when). NOTE: this records the resolution only — it does NOT apply the suggested fix to the context item; applying fixes happens in the Marcora web app. Requires admin or editor role. Confirm with the user before dismissing or resolving a finding they haven't explicitly decided on. Errors: - Invalid status. Must be one of: acknowledged, dismissed, resolved. - Finding not found. / You do not have access to this finding.
update_plan
ChatGPTPartial update of a content plan: only the keys you send change; unspecified keys are preserved. Call get_plan FIRST to see the current state, then send a minimal diff. Use produce_plan (not this) to generate a plan's content. Must-know rules: - plan_uuid is required (from create_plan or list_plans). - reference_document_ids, context_collection_ids and targeting_dimension_ids: a non-empty array REPLACES the full set (not merge). An empty array [] is ignored, so this tool cannot clear them. - blueprint_id and due_date: null CLEARS the field. project_id and category_id: null is ignored; pass a new value to change one. blueprint_id takes a blueprint UUID (from list_blueprints) or integer id. - assigned_to must be the NUMERIC user id of a current team member (emails and names are rejected). Assigning a private plan to someone else auto-promotes it to "team" visibility. - visibility ("private" | "team"): only the plan's creator may change it. Mention the change to the user before sending it. - target_stage triggers a stage transition, validated server-side (use the underscore form In_Process). Common moves: Suggested → Accepted (user accepts), any open stage → Dismissed (terminal), Complete → Accepted (re-open: clears produced_content_id; confirm with the user FIRST). - Never send server-managed fields (source, source_metadata, created_by, team_id, id, produced_content_id, the timestamps); the server rejects them. Present link_url exactly as returned. Input roles: - plan_uuid: required. The UUID from a prior create_plan or list_plans response. - title / description / prompt: update the human-facing or executable text. - blueprint_id / project_id / category_id / due_date: update executable parameters (null clears blueprint_id and due_date; null is ignored for project_id and category_id). - assigned_to: there is no user-lookup tool; get the id from the user or from another plan's assigned_to/created_by. Self-assignment does not change visibility. Allowed transitions: Suggested → Accepted (user accepts the suggestion) Suggested → Dismissed (user rejects it) Accepted → In_Process (content is being created; usually triggered automatically) Accepted → Dismissed In_Process → Complete (content reached ready; usually triggered automatically) In_Process → Accepted (content was deleted; plan reverts) In_Process → Dismissed Complete → Accepted (re-open the plan; clears produced_content_id and completed_at) Complete → Dismissed Dismissed → (nothing; terminal) Do NOT send (server rejects with InputError "{field} is immutable" or "{field} is server-managed"): source, source_metadata, created_by, team_id, id, plan_uuid (as an update value), produced_content_id, created_at, updated_at, completed_at, dismissed_at. Usage patterns: - Dismiss a plan: { plan_uuid: X, target_stage: "Dismissed" } - Re-open a Complete plan: { plan_uuid: X, target_stage: "Accepted" } (confirm with the user first) - Reassign: { plan_uuid: X, assigned_to: <user_id> } - Accept a Marcora-suggested plan: { plan_uuid: X, target_stage: "Accepted" } Errors: - Missing param: plan_uuid. Pass the plan_uuid from a prior list_plans or create_plan response. - NotFound: plan_uuid doesn't exist or is not visible to your team. - InputError: stage transition {from} → {to} not allowed. - InputError: source is immutable / source_metadata is immutable. - InputError: assigned_to is not a member of the team. - InputError: assigned_to must be the numeric user id of a team member (a non-numeric value was sent). - InputError: only the plan creator can change visibility. - InputError: visibility must be one of [private, team]. - AccessDenied: JWT doesn't resolve to the right team context. Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
update_playbook
ChatGPTEdit a content playbook. Any playbook is fully editable (no lock-in) — imported or authored alike. Pass only the fields to change: name and/or description patch in place. If items is provided it FULLY REPLACES the playbook's items and their order; omit items to leave them untouched. Changing visibility ("private" | "team") is CREATOR-ONLY — non-creators get InputError. When to use: when the user wants to rename, re-describe, or restructure a saved playbook — reorder, add, remove, or rewrite its items (e.g. "add a follow-up email to my launch playbook", "reorder these steps"). Links: present link_url to the user exactly as returned — copy it character for character. Never retype, shorten, or rebuild a link or the IDs inside it.
update_project
ChatGPTUse this tool to update mutable fields on an existing Marcora project. To set or change the project's brief, pass an existing content UUID as project_brief_id - the tool resolves it to the appropriate document wrapper internally. If the content isn't already attached to the project, this tool will attach it for you AND set it as the brief in one call — you don't need to add the content separately first. To READ the existing brief instead of replacing it, do not come here. get_project returns the brief as a project_brief block with an excerpt, and get_content with that block's content_id returns the full body. Read it before you change it — the brief is the project's authoritative statement of premise and structural decisions, and overwriting it blind discards them. Important notes: - Only fields you pass are updated (PATCH semantics). Omit a field to leave it unchanged. - visibility must be exactly team or private. - status must be exactly active or archived. - name must be non-empty when provided. Common use cases: - "Set the brief on the Acme Launch project to <content>" -> call with project_id and project_brief_id (works whether or not the content is already in the project). - "Rename the project" -> call with project_id and name. - "Make the project private" -> call with project_id and visibility="private". - "Archive the project" -> call with project_id and status="archived".
add_context
Claudeask_content_assistant
Claudeconvert_markdown_to_word_doc
Claudecreate_blueprint
Claudecreate_blueprint_draft
Claudecreate_content
Claudecreate_context_collection
Claudecreate_external_share
Claudecreate_project
Claudecreate_workflow
Claudefinalize_blueprint_draft
Claudeget_blueprint
Claudeget_brand_foundation
Claudeget_content
Claudeget_context_item
Claudeget_current_user_info
Claudeget_generation_status
Claudeget_project
Claudeget_relevant_context
Claudeget_workflow
Claudeget_workflow_runs
Claudelist_blueprints
Claudelist_content
Claudelist_content_categories
Claudelist_context_collections
Claudelist_context_items
Claudelist_projects
Claudelist_targeting_dimensions
Claudelist_workflows
Clauderun_workflow
Claudeupdate_brand_foundation
Claudeupdate_content
Claudeupdate_context
Claudeupdate_project
Claudeupdate_workflow
Claude
