Skip to main content
Glama

Server Details

Marcora is the context layer for go-to-market teams: your positioning, brand voice, and product facts in one source of truth that your AI tools read from. This remote MCP server connects Claude, ChatGPT, Cursor, and other MCP clients to shared brand context for product marketing, sales enablement, and customer success. Read your Brand Foundation and Reference Library, save new context, and create and share battlecards and onboarding guides.

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
Marcora: Brand Context & Writing

TDQS

A4.1/5.0

Scored across 63 tools

Disambiguation4/5

Despite the size, most tools have unmistakable resource+action purposes (create_plan vs produce_plan, add_context vs update_context, check_content_grounding vs get_grounding_result). The few genuinely confusable clusters are mitigated by very explicit descriptions: create_blueprint vs create_blueprint_draft, apply_grounding_fix vs update_ci_finding_status, and get_share_link_activity vs list_share_link_activity. Descriptions do heavy lifting to keep boundaries clear, so an agent can usually select correctly.

Naming Consistency5/5

Every tool follows snake_case verb_noun order (list_content, create_playbook_from_plans, instantiate_playbook, trigger_health_audit_scan, set_active_team). Nouns are consistent per resource family (content, context, plan, playbook, workflow, blueprint, finding), making the surface predictable to scan.

Tool Count2/5

63 tools is far past a comfortable ceiling, even for a broad content-marketing platform spanning content, context, blueprints, plans, playbooks, workflows, grounding, findings, share links and team admin. Several families could be consolidated (e.g. blueprint draft/finalize/import variants, the grounding poll/fix trio) and the raw count raises selection cost and context bloat.

Completeness4/5

Coverage is deep: create/get/list/update exist for content, context items, projects, plans, playbooks, workflows, brand foundation, findings and share links, plus niche lifecycle tools (finalize draft, instantiate playbook, run workflow, apply fix). The main gap is deletion: there is no delete for content, context items, collections, blueprints or playbooks (archive/dismiss stand-ins exist), which agents must route around.

Publisher details

Operator
Marcora
Operator website
https://marcora.ai
Vendor relationship
First-party
Restrictions
You'll need a Marcora account.

Available Tools

63 tools
add_contextA
Destructive
Inspect

Adds 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.

Call transcripts: text that looks like a call transcript (WebVTT or SRT, or lines with speaker labels and timestamps) is saved as a call in Calls, as the Add form does, and the result says so (saved_as_call: true). Pass as_call: true to save any text as a call, or as_call: false to keep it an ordinary context item. A call is Only me (visible only to the person who added it) unless you pass audience: "team"; ask the user if you are unsure who should see it. Optional call details: call_date (ISO 8601), call_kind, call_company; anything left out is worked out from the transcript. A call takes content only. call_date, call_kind, call_company and audience: "only_me" apply to calls only: sending one for text saved as an ordinary item is rejected rather than ignored. The summary is written after the save; call.summary_status shows where it is, and get_context_item returns the summary once ready.

Team audience on ordinary items: when the user asks for the item to be saved for the team, pass audience: "team" (on content, import_url or connected_webpage_url), even with a collection_id or project_id. It is accepted when the item will be team-visible. In a private collection or private project it is refused with an error and nothing is saved: tell the user why and offer a shared collection, a team-visible project or the Reference Library. Never fall back to a private save without asking the user. Every successful save returns audience: who can actually see the item (team, project_members or only_me), whether or not you passed audience. Tell the user that plainly.

Importing calls from a connected app: a fourth way, import_from: { toolkit, call_ids }, brings in calls the user keeps in a call-recording app. Use it instead of content, import_url and connected_webpage_url, and without as_call, call_date, call_kind or call_company. First find the calls with the app's own list or search tool in your session, then pass their ids (1 to 10) in this ONE call: Marcora fetches and cleans each transcript itself through the user's own connection, so never retype or paste a transcript. toolkit is fathom, gong, fireflies, googlemeet or wispr_flow_mcp. Google Meet and Wispr Flow imports are Beta. For Google Meet, pass the bare ID from conferenceRecords/{id}, or doc:{document_id} for a saved transcript. Recent discovery is organizer-only within 30 days; a known conference record still requires access. Saved transcripts require your own active Google Meet and Google Docs connections in the same team; discovery also requires Google Drive and searches by document creation window. The document must contain a date and timestamped speaker-labelled transcript, not just Gemini notes. Meet supplies no original meeting title or participant emails; automatic Meet imports stay Only me and do not support attendance filters. For Wispr Flow, use a meeting ID from search: recorded meetings only, not dictation or scratchpad. Wispr attendee search uses calendar invitees; narrow a search that reaches 1,000 matches. audience, project_id and collection_id work as they do for calls (Only me and filed in Calls unless you say otherwise; a Collaborator must pass project_id; choose one of project_id or collection_id). name is ignored here because each call keeps its own title. The result lists every call as imported, duplicate, not_ready or failed, with where it was filed and who can see it, and never includes transcript text. If the app is not connected the call fails with an error that names the app and carries its Connect link: give the user that link, and retry once they have connected. When at least one call was imported the result carries automatic_import_link: offer it so the user can set up automatic import; it opens the rule editor with these choices filled in and nothing is saved until the user saves it. To find out whether an app is connected, or to get a Connect link before importing, use find_app.

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: a processing import_url does not reserve a slot: if another add fills the plan's last slot, the import is refused when it finishes and adds nothing; a new web page holds its slot from the start. 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.

Inputs: name (required), as_call, content, audience, +8 more. Returns: id, call, name, content, +14 more

apply_grounding_fixA
Destructive
Inspect

Applies Marcora's recommended fix for one or more findings ("yes, do recommendation "). 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_ci_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 (only built-from pass-1 conflicts and add_to_library_eligible gaps have fixes; company gaps and pass-2 note outcomes have none). 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 (a company_material conflict's fix revises the document, never your facts). 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.

Two-pass grounding rules: only conflicts from built-from sources (pass 1) and completely searched, nowhere-supported true gaps (add_to_library_eligible: true) produce actionable findings. A conflict with conflict_scope: "company_material" means the document disagrees with your material about another named company rather than your own facts (team_facts); its fix revises the document (context_item_id: null), never your facts. A company gap offers no add-to-library (add_to_library_eligible: false; the backend refuses it). Pass-2 disagreements from other collections (bucket: "note" or notes[] on a supported claim) and recorded drafting research (web_research, connected_app) never produce conflict findings or fix actions, and grounding never browses.

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[].

  • Finding not found. Per finding, surfaced in errors[]: a finding_id that is unknown or that you cannot read. That finding is skipped; the others still run.

  • 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.

  • Nothing was applied. This document has private source history (an isError result). A fix on such a document cannot update a context item in your reference library. The message names the next step that will work: call again with the same finding_ids and without context_item_overrides when that fixes the document itself; otherwise revise the document with update_content, then re-check.

Inputs: finding_ids (required), context_item_overrides. Returns: jobs, errors, queued, skipped, +1 more

ask_content_assistantA
Destructive
Inspect

Sends 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.

Inputs: prompt (required), content_id (required), project_id, ai_provider, +4 more. Returns: status, generation_id

check_content_groundingA
Destructive
Inspect

Runs Marcora's two-pass content grounding on a piece of content: extracts its factual claims, checks them against built-from sources (pass 1) and other collections (pass 2), and returns which claims are supported, conflict, note, or gap. Grounding never browses.

Two-pass rules: conflicts come ONLY from what the document was built from (pass 1); other collections (pass 2) can support a claim or add a note (bucket: "note" or notes[]), never a conflict; recorded research (web_research, connected_app) appears as a source.

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. Present link_url exactly as returned.

How two-pass grounding works:

  • Pass 1 (built-from sources): checks the root Reference Library, Brand Foundation, the project brief and project items, and any collections/items used in drafting, plus recorded drafting research (web_research, connected_app). Conflicts come ONLY from authoritative built-from sources; recorded research can support a claim, never conflict.

  • Pass 2 (other collections): checks other visible collections not used to build the document. They can support a claim or add a note (bucket: "note" or notes[] on a supported claim), never a conflict. Notes have no finding or fix action; only completely searched, nowhere-supported true gaps have add_to_library_eligible: true.

  • Company attribution (claim_subject and conflict_scope): each claim and finding reports claim_subject (team, company, general, or unknown, with company_name and confidence). A claim about your own company (team) is checked only against material about your company; a claim about another named company (company) is checked against material about that company, which can support or contradict it. On conflicts, conflict_scope is team_facts (disagrees with your own facts) or company_material (the document disagrees with your material about that company, not your own facts). A company conflict's fix revises the document, never your facts, and a company gap offers no add-to-library (add_to_library_eligible: false; the backend refuses it).

Studio Credits: grounding uses team Studio Credits (Marcora estimates the cost first and won't start a run the team's balance can't cover) and requires an editor role. Full findings go to the content's creator; others get summary counts only (details_visible=false). 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.

  • ci_not_eligible (403): Studio Credits or Context Intelligence availability check failed.

  • You are not authorized to perform this action (403): the token's user lacks an editor role on the team.

  • This check cannot use the document’s private sources (an isError result): the document was built from Only me sources, which are never sent to an AI app. When they are the caller's own, the message adds a link to check the document privately in Marcora; relay it to the user.

Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.

Inputs: title, content, content_id. Returns: claims, status, message, scan_id, +9 more

convert_markdown_to_word_docAInspect
Use 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).

Inputs: markdown_content (required), filename, document_url. Returns: filename, download_url

create_blueprintAInspect
*SYNCHRONOUS — 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.

Inputs: name (required), category_id (required), source_content (required). Returns: name, summary, category, link_url, +7 more

create_blueprint_draftAInspect
Use 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.

Inputs: name (required), content (required), instructions (required), category_id. Returns: id, uuid, title, content, +1 more

create_contentAInspect

Saves 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 and the draft's content_id/link_url (it saves itself when done); 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. reference_content_ids (see above; instructions paths only).

Studio Credits: the instructions paths use Studio Credits, charged when the document completes at the model's cost (1 credit = 5¢, rounded up; typically Quick 1-2, Multi-model 6-7). Starting needs 1 credit available for Quick, 5 for Multi-model; otherwise the call fails with an insufficient_credits error (code 402) and nothing is generated. Saving content uses none.

Plan integration (additive):

  • When the user has an active plan they want to fulfil, pass plan_id with the plan's UUID. The content is linked to the plan and the plan moves to In_Process automatically.

  • plan_id is purely associative: the endpoint does NOT look up plan parameters. Use get_plan to read prompt, blueprint_id, project_id, collection IDs and targeting dimension IDs, then pass them explicitly here alongside plan_id.

  • Do NOT pass plan_id if the plan is in Complete stage. Call get_plan first; if Complete, call update_plan with target_stage='Accepted' to re-open it (confirm with the user), then call create_content.

  • Linkage scope: plan_id links plan and content automatically ONLY with blueprint_uuid (the async path). The synchronous paths accept plan_id without error but do not establish the link. For the standard plan-fulfilment flow, pass blueprint_uuid from the plan.

  • An invalid plan_id (not found, wrong format) is logged and content creation still SUCCEEDS.

Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.

Inputs: content, plan_id, project_id, ai_provider, +9 more. Returns: Quick without a blueprint_uuid (and verbatim `content`) returns the content obj…

create_context_collectionAInspect
Create 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.

Inputs: name (required), is_private (required), description (required). Returns: id, name, link_url, created_at, +2 more

create_external_shareAInspect
Creates 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.

Inputs: content_id (required), expires_at. Returns: share_link

create_planAInspect

Creates 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, or rebuild a link or the IDs inside it.

Inputs: title (required), prompt, source, due_date, +11 more. Returns: id, stage, title, prompt, +21 more

create_playbookAInspect

Create 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.

Inputs: name (required), items, visibility, anchor_date, +1 more. Returns: id, name, items, team_id, +7 more

create_playbook_from_plansAInspect

Create 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.

Inputs: plan_ids (required), name, visibility, description. Returns: id, name, items, team_id, +7 more

create_projectAInspect
Use 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.

Inputs: name (required), visibility, project_brief_content, project_brief_instructions. Returns: name, link_url, project_id, project_brief

create_workflowAInspect

Creates a new workflow template (a saved, repeatable multi-step agent task) for the user's current team. New workflows are saved Inactive; set one Active with update_workflow only once the user confirms. Before creating, check list_workflows with a search filter for a duplicate name, and confirm the name with the user.

Required: name, steps (ordered; each specific enough for a fresh agent to do without follow-up questions) and allowed_tools (non-empty: the tools the runner agent is told it may use; prefer tight allowlists). Include schedule_config ONLY if the user explicitly wants it to run on a schedule.

Two switches, two vocabularies, never mixed. The workflow's status is Active or Inactive. Its schedule, if any, is On or Paused. Never call a schedule "active"/"inactive" or a workflow "paused"/"on". Active does not mean running; it means the workflow is allowed to run. It runs on its own only when it is Active AND its schedule is On.

Schedules are always saved Paused. No MCP tool can turn a schedule On: the user does it in the Marcora app with Resume schedule. update_workflow silently ignores schedule changes and still returns success.

What to tell the user: the response carries a next_step stating what will and won't run, computed from what was saved. Lead your reply with it. When a schedule was saved it also carries schedule (is_enabled: false = Paused, plus a plain-language summary) and link_url for the user to review it and click Resume schedule. Never say or imply the workflow will run on its own unless it is Active and its schedule is On.

Schedule shapes: daily at a set time, or weekly on one or more days at a set time (days_of_week, e.g. [1,3,5], with one hour). There is no second time of day and no every-N-hours interval.

Present link_url exactly as returned.

Input roles:

  • name: human-readable name. Confirm with the user before creating.

  • description: one or two sentences. Becomes part of the runner's system prompt.

  • steps: ordered list. Each step should be specific enough that a fresh agent can do it without follow-up questions.

  • inputs: declare what the workflow needs (e.g. topic, date_range).

  • allowed_tools: REQUIRED, non-empty. The tools the runner agent is told it may use when the workflow runs (an instruction in the runner's prompt, not a separate permission check). A workflow cannot be created without an explicit allowlist. Prefer tight allowlists, especially for scheduled runs.

  • tags: optional.

  • schedule_config: include ONLY if the user explicitly wants a schedule. See the schedule_config input for its two modes; prefer the calendar mode (hour, plus days_of_week for weekly).

What actually runs needs BOTH switches; describe the pair that exists when you finish:

  • Inactive → nothing runs, by any route (manual runs are refused too).

  • Active, no schedule → runs only when started manually; never starts by itself.

  • Active, schedule Paused → manual runs work; it won't run on its schedule until the user turns the schedule on with Resume schedule in the app.

  • Active, schedule On → runs on its schedule.

  • Inactive, schedule On → nothing runs until the workflow is set Active.

After a follow-up call: if you then call update_workflow (for example to set the workflow Active), describe the state after THAT call (its next_step), not this one. Activating a workflow whose schedule is Paused still leaves it not running on its schedule; saying "it's inactive, go activate it" after you activated it is just as false. "Created and active" misled a real customer into thinking their workflow was running.

Cadences: "3 times a week", "every weekday" and "Mondays and Thursdays" are expressible exactly: use weekly with days_of_week and one hour, pick the days with the user's intent in mind and say which you chose; do not fall back to an interval. If the user asks for something the two shapes can't express (e.g. "twice a day", "every 36 hours"), save the closest schedule you can, tell the user exactly what you saved (quote schedule.summary) and that it approximates what they asked for. Never present an approximation as the schedule they requested.

Usage patterns:

  • The returned id is a UUID string. Use it as workflow_id in get_workflow / update_workflow / run_workflow / get_workflow_runs.

  • Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.

Inputs: name (required), steps (required), allowed_tools (required), tags, +3 more. Returns: id, name, tags, steps, +11 more

finalize_blueprint_draftAInspect
*SYNCHRONOUS — 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.

Inputs: draft_uuid (required), name, category_id. Returns: name, summary, category, link_url, +7 more

find_appA
Read-onlyIdempotent
Inspect

Looks up the apps Marcora offers to connect (for example Gong or Fathom), by name or by what they do (for example "call recordings"). Call it BEFORE telling the user you can't reach an app or sending them to connect one: say only what it returns, and never claim an app is offered unless it appears in the result.

Each match carries the user's own connection_state (connected, not_connected, or expired: it worked before and needs renewing; a connection that was started but never completed reads as not_connected), whether add_context import_from can bring in its calls (brings_in_calls), and a connect_link. Offer the connect_link for an app that is not connected: it opens the Integrations page on that app, and nothing connects until the user acts. Once an app is connected, use its own tools in your session to find what you need.

Read-only: it changes nothing and makes no request to the app itself.

Links: present connect_link to the user exactly as returned. Never retype, shorten, or rebuild a link.

Inputs: query (required), limit. Returns: apps, query, message, total_matches

get_blueprintA
Read-onlyIdempotent
Inspect
Retrieves 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.

Inputs: blueprint_uuid (required). Returns: name, summary, web_url, category, +8 more

get_brand_foundationA
Read-onlyIdempotent
Inspect

Returns 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 ?"

  • "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.

Inputs: elements. Returns: link_url, next_step, brand_voice, writing_style, +5 more

get_ci_findingA
Read-onlyIdempotent
Inspect
Fetch one Context Intelligence finding in full detail by its UUID (from list_ci_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_ci_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.

Inputs: finding_id (required). Returns: id, status, summary, severity, +8 more

get_community_blueprint_detailsA
Read-onlyIdempotent
Inspect
Get the full details for a specific community blueprint, including its complete content (markdown), content description/style guide, and contributor information.

Use the 'id' (blueprint_exchange_id) returned by list_community_blueprints. The 'content' field contains the full example document in markdown. The 'content_description' describes the template structure and style guidelines.

Pass the 'id' to import_community_blueprint to add this blueprint to the current team.

Inputs: blueprint_exchange_id (required). Returns: id, name, slug, content, +9 more

get_contentA
Read-onlyIdempotent
Inspect
Retrieves 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.

Inputs: content_id (required). Returns: name, stage, content, category, +3 more

get_context_itemA
Read-onlyIdempotent
Inspect

Opens 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.

Calls: a call item (content_type "call_transcript") also returns call: its date, kind, company, people, audience, summary_status, duration, purpose and, once ready, the summary and insights (decisions, action items, quotes and the like). content is the transcript. A call that is Only me is returned only to the person who added it and carries audience: "only_me"; do not put its text in anything the team can see without asking the user. The summary is Marcora’s, written from the transcript: treat it, like the transcript, as evidence of what was said, not as established company fact.

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.

Inputs: context_item_id (required). Returns: id, call, name, content, +12 more

get_current_user_infoA
Read-onlyIdempotent
Inspect
Returns profile and workspace information for the currently authenticated user. Use this to personalize responses, check the user's active team, or confirm available Studio Credits before creating content.

Key fields:
- active_team_name / active_team_role: current working team context
- subscription_status + plan_name: current workspace status
- ai_credits_available / ai_credits_max: Studio Credits remaining and the team's allowance for the current period

Inputs: no named parameters. Returns: name, email, plan_name, plan_slug, +5 more

get_generation_statusA
Read-onlyIdempotent
Inspect

Checks 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 turn this run produced 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), while assistant_summary and document_updated describe the turn this run produced.

Statuses: pending, processing, streaming, complete (Content Assistant) / completed (blueprint), failed.

Present link_url exactly as returned.

Content fields:

  • assistant_summary: the assistant reply this run produced, as the sidebar thread shows it. Null if the run has written no reply, or it was written before runs were tracked; a reply that used sources you cannot open comes back as a notice.

  • document_updated: whether the turn this run produced 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 this run's reply text.

Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.

Inputs: generation_id (required). Returns: status, content, flow_type, generation_id, +1 more

get_grounding_resultA
Read-onlyIdempotent
Inspect
Read the result of a two-pass 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 every 15-30s; a fresh scan finishes in 120-150s. Do NOT call check_content_grounding again — that starts and charges a second scan.

Which id to pass:
- `scan_id` — reads that exact scan, whatever its status. Use this when polling.
- `content_id` (no scan_id) — reads the latest COMPLETED grounding for that document and skips any scan still running, so do NOT use it for polling (you would get the previous result back marked complete).

Two-pass result: conflicts come only from what the document was built from (pass 1); other collections (pass 2) can support a claim or add a `note` (`bucket: "note"` or `notes[]`), never a conflict. Each claim and finding reports `claim_subject` (`team | company | general | unknown`): a claim about another named company is checked against material about that company, which can support or contradict it; `conflict_scope: "company_material"` means the document disagrees with your material about that company, not your own facts (`team_facts`). A company conflict's fix revises the document, never your facts, and a company gap offers no add-to-library (`add_to_library_eligible: false`; the backend refuses it). Recorded research (`web_research`, `connected_app`) appears as a source; grounding never browses. Never starts a scan or charges credits.

Errors:
- Provide 'scan_id' or 'content_id' (400).
- Not a valid UUID (400).
- Grounding result not found. (404).
- scan_id and content_id refer to different content (400) — pass scan_id alone.

**Links:** present `link_url` to the user exactly as returned — never retype, shorten, or rebuild it.

Inputs: scan_id, content_id. Returns: claims, status, message, scan_id, +9 more

get_planA
Read-onlyIdempotent
Inspect
Fetch 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.

Inputs: plan_uuid (required). Returns: plan

get_playbookA
Read-onlyIdempotent
Inspect

Fetch 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.

Inputs: playbook_id (required). Returns: id, name, items, team_id, +7 more

get_projectA
Read-onlyIdempotent
Inspect
Returns 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`.

Inputs: project_id (required). Returns: id, name, status, members, +5 more

get_relevant_contextA
Read-onlyIdempotent
Inspect

Searches 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 (blog post, email, social post, landing page, ad): 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 (Marcora writes): it 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; be specific.

  • include_brand_foundation: true on the FIRST call of a conversation (adds company overview, brand voice, style and examples); false or omitted after.

  • include_only_me: true also searches the user's own Only me items (never another member's).

  • 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.

Only me items: by default only Team items are searched. With include_only_me: true the user's own Only me items, including Only me calls, are searched too, never another member's. Calls filed in Calls come back only when that Calls collection's id is in collection_ids, or through their project; on its own include_only_me: true returns none of them. If you then write material you read from an Only me source into a team-visible document, the write is refused until the user agrees.

Calls window: calls adds calls to the search: { date_from, date_to, kinds, companies }, every field optional (dates as YYYY-MM-DD or ISO 8601; kinds from customer, external, team_meeting, one_on_one, recorded; {} is every call you may use). Each call carries its date, kind and company in its heading. Only Team calls come back, never a teammate's Only me call; include_only_me: true adds your own Only me calls. A Team call filed in a private project or private collection is treated like an Only me call: its source carries audience: "only_me".

Sources: each sources entry carries the item name, content_type, audience (team or only_me), 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 it in automatically.

Errors when you pass project_id: "Project not found" means the project doesn't exist or belongs to a team other than your active team (check list_projects, or set_active_team if it is in another team). "You are not a member of project " means the project is private and you are not a member: ask a member to add you, or search without project_id. Neither error returns any context or brief.

Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.

Inputs: prompt (required), calls, project_id, collection_ids, +6 more. Returns: sources, next_step, project_brief, context_rag_ids, +5 more

get_team_infoA
Read-onlyIdempotent
Inspect
ALWAYS 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.

Inputs: no named parameters. Returns: teams

get_workflowA
Read-onlyIdempotent
Inspect
Read-only. Returns one workflow template by `workflow_id`: its name, description, status (Active / Inactive), ordered steps, declared inputs, allowed_tools and tags, plus its triggers (including the schedule, if any) and its latest run, and a `run_state` sentence saying what will and won't run. Call it before update_workflow to see the current values: steps, inputs and allowed_tools are replaced outright when updated.

Input roles:
- workflow_id: UUID string of the workflow to fetch.

Usage patterns:
- Before update_workflow: call get_workflow, read the current `steps` / `allowed_tools` / `inputs`, then construct your update payload with those existing values preserved for any field you aren't changing.
- To say whether it runs, and how: read `run_state` and follow it. It states both switches — the workflow's `status` (Active / Inactive) and its schedule (On / Paused / none) — and what that means will and won't run. `schedule` is the read-back of its schedule (`is_enabled`, a plain-language `summary`), present only when it has one.
- Two switches, two vocabularies: the workflow is Active or Inactive; the schedule is On or Paused. Never mix them, and never call a workflow Active without saying whether its schedule is On, Paused or absent — it runs on its own only when it is Active AND its schedule is On.
- To show last run outcome: inspect `_latest_run.status` + `_latest_run.completed_at`.

**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.

Inputs: workflow_id (required). Returns: workflow

get_workflow_runsA
Read-onlyIdempotent
Inspect
Inspect workflow run history. Two modes controlled by run_id presence:

Input roles:
- workflow_id: UUID string of the workflow.
- run_id: UUID string. If present → single-run detail with step logs and tool call logs. If absent → paginated list of runs.
- status: list-mode filter. Ignored in single mode.
- page / per_page: list-mode pagination.

Usage patterns:
- When the user asks "did my workflow run?": call with just workflow_id (list mode) and look at items[0].status + items[0].completed_at.
- When the user asks "what did that run do?": call with workflow_id + run_id (single mode) and read _step_logs and _tool_call_logs.
- When troubleshooting failures: filter list mode by status="failed", then pull each detail.
- Each run's `id` is a UUID string. The `link_url` on each run points to its detail page in Marcora.

**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.

Inputs: workflow_id (required), page, run_id, status, +1 more. Returns: Workflow run history. Shape depends on whether run_id was supplied. List mode (…

import_community_blueprintAInspect
Use this tool to import a blueprint from the Marcora community exchange into your team's library. Once imported, use it like any of your own blueprints to generate content. Workflow: 1) Use list_community_blueprints to browse and find a blueprint. 2) Copy its id (the `id` field of the list_community_blueprints item). 3) Call this tool to import it. 4) Use list_blueprints to confirm it appears in your library. 5) Use create_content with the returned uuid as blueprint_uuid to generate content.

Inputs: blueprint_exchange_id (required), _frontend_realtime_key. Returns: id, name, uuid, content, +3 more

instantiate_playbookAInspect

Run 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.

Inputs: playbook_id (required), project_id, anchor_date, assigned_to, +1 more. Returns: run, plans, run_id, playbook_id, +1 more

invite_userA
Destructive
Inspect
Invite 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.

Inputs: role (required), email (required), project_id. Returns: role, email, emailed, message, +6 more

learn_marcora_toolsA
Read-onlyIdempotent
Inspect

Returns 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.

Inputs: topic. Returns: title, topic, topics, content, +1 more

list_blueprintsA
Read-onlyIdempotent
Inspect
Get 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.

Inputs: no named parameters. Returns: All blueprints in your team's library, flattened across content categories.

list_ci_findingsA
Read-onlyIdempotent
Inspect
List 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.

Inputs: page, status, per_page, severity, +1 more. Returns: items, curPage, nextPage, prevPage, +1 more

list_community_blueprintsA
Read-onlyIdempotent
Inspect
Browse community blueprints available for import, as a compact index: id, slug, name, category and Featured flag. Featured first, then newest. Find a blueprint by its name or category here.

Summary, contributor, input instructions and the full content are not in this list: pass the returned 'id' to get_community_blueprint_details first. Large catalogs come back in pages of up to 150 (max 300); when next_offset is not null, call again with offset=next_offset. Pass category to narrow the list.

Inputs: limit, offset, category. Returns: total, next_offset, community_blueprints

list_contentA
Read-onlyIdempotent
Inspect

Lists 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.

Inputs: search. Returns: Returns all content visible to the current user as a single unified array. Cont…

list_content_categoriesA
Read-onlyIdempotent
Inspect
Returns 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).

Inputs: no named parameters. Returns: categories

list_context_collectionsA
Read-onlyIdempotent
Inspect
Returns 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.

Inputs: no named parameters. Returns: collections

list_context_itemsA
Read-onlyIdempotent
Inspect

Lists the context items the user can see (reference library, projects and collections), newest first. Use it to browse, filter and find context-item IDs; pass an ID to get_context_item for the full text. To find the passages that answer a question, use get_relevant_context instead.

Each item carries collection_id, project_id (both nullable), a short content_intro and a link_url. Set reference_library_only: true to return only items filed in no project and no collection.

Optional filters, combinable: content_type (for example call_transcript, manual, webpage); date_from / date_to (YYYY-MM-DD or ISO 8601; compared with the call's own date for calls and the created date for every other item); and, for calls, kinds and company. Only calls have a kind or company, so setting either returns calls only. A call item carries a call block: date, kind, company, people, audience, summary_status.

Items marked audience: "only_me" (a call added as Only me) are private to their owner: you see only your own, never a teammate's, an admin's or another member's. Do not put an Only me item's text in anything the team can see without asking the user.

Present link_url exactly as returned.

Optional search: a natural-language query that sorts 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 is more similar; null for an item with no indexed passages yet, which sorts last). Search only re-orders: every item you can see is still returned, with no cutoff.

Web-page items (content_type "webpage") carry source_url, the tracked page URL, useful for spotting which items can be refreshed (update_context refresh_webpage); it is null for other items.

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.

Other ways to find context-item IDs: get_project(project_id).context_items for one project, and the sources array of get_relevant_context.

Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.

Inputs: kinds, search, company, date_to, +3 more. Returns: context_items

list_plansA
Read-onlyIdempotent
Inspect

Lists 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.

Inputs: page, sort, stage, source, +7 more. Returns: Paginated plan summary results.

list_playbooksA
Read-onlyIdempotent
Inspect

List 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.

Inputs: no named parameters. Returns: items, itemsTotal

list_projectsA
Read-onlyIdempotent
Inspect
Returns 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.

Inputs: no named parameters. Returns: projects

list_targeting_dimensionsA
Read-onlyIdempotent
Inspect
Returns 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.

Inputs: no named parameters. Returns: dimensions

list_workflowsA
Read-onlyIdempotent
Inspect
List workflows for the user's current team. Supports optional status filter and substring search.

Input roles:
- status: "active" | "inactive" | "archived". Omit to return all.
- search: substring to match against workflow name.
- page / per_page: pagination. Default page=1, per_page=20, max per_page=100.

Usage patterns:
- Before create_workflow: call list_workflows with `search:` to check for duplicate-name workflows.
- When the user asks "what workflows do I have": call with no filters.
- When the user asks "what's my automation doing?": filter by status="active" — but Active only means a workflow is allowed to run. Whether it runs on its own depends on its schedule (On or Paused), which the list does not show; call get_workflow and follow its `run_state` before saying any workflow is running. A workflow is Active/Inactive, a schedule is On/Paused — never mix the two.
- Each item's `id` is a UUID string. Use it as `workflow_id` in get_workflow / update_workflow / run_workflow / get_workflow_runs.

**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.

Inputs: page, search, status, per_page. Returns: items, curPage, nextPage, prevPage, +1 more

produce_planAInspect

Produces (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.

Inputs: plan_uuid (required), ai_provider, generation_mode, use_extended_thinking. Returns: path, stage, message, link_url, +1 more

run_workflowA
Destructive
Inspect
Manually run a workflow. Creates a run record and starts an automated agent session that carries out the workflow's steps, using Marcora tools and the user's connected apps; the session is told to use only the tools in the workflow's allowed_tools. Returns the run row — check .status to know what happened.

Input roles:
- workflow_id: UUID string of the workflow to run.
- input_values: object matching the workflow's declared inputs schema. Call get_workflow first if unsure.

Only an **Active** workflow can run. An Inactive (or archived) one is refused, and the refusal can reach you as an unreadable protocol error rather than a clear message — so if you are not sure of the status, check it with get_workflow first. If it is Inactive, tell the user so, and set it Active with update_workflow if they want it to run. The schedule has nothing to do with manual runs: a Paused schedule does not stop run_workflow, and an On schedule does not let an Inactive workflow run.

Usage patterns:
- Always inspect the returned .status:
  - "running" → dispatch succeeded; the agent session is live.
  - "failed" → dispatch failed; .error_reason has the cause. Tell the user specifically what went wrong.
  - "skipped" → the runner decided no work was needed (rare for manual runs, common for scheduled).
- For scheduled runs, prefer creating a trigger via create_workflow's schedule_config — don't loop run_workflow calls.
- input_values must match workflow.inputs schema. For workflows with no declared inputs, pass {} or omit.
- The returned `id` is a UUID string for the workflow_run. Use it as `run_id` in get_workflow_runs (single-mode) to inspect the run.

**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.

Inputs: workflow_id (required), input_values. Returns: id, status, link_url, error_reason, +4 more

set_active_teamA
Idempotent
Inspect
Set 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).

Inputs: team_id (required). Returns: active_team, previous_team_id

trigger_health_audit_scanA
Destructive
Inspect
Start 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_ci_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 uses team Studio Credits — Marcora estimates the cost first and won't start a run the team's balance can't cover. 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_ci_findings afterwards.

Errors:
- ci_not_eligible (403) — Studio Credits or Context Intelligence availability check 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}.

Inputs: no named parameters. Returns: status, message, scan_run_id

update_brand_foundationA
DestructiveIdempotent
Inspect
Overwrites 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.

Inputs: content (required), element (required). Returns: content, element, link_url

update_ci_finding_statusA
DestructiveIdempotent
Inspect
Update 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_ci_findings / get_ci_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.

Inputs: status (required), finding_id (required). Returns: The updated finding row, including the new status (and resolved_at/resolved_by…

update_contentA
DestructiveIdempotent
Inspect

Updates 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.

Inputs: content_id (required), stage, content, project_id, +5 more. Returns: name, stage, content, category, +3 more

update_contextA
DestructiveIdempotent
Inspect

Updates 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.

Project and collection placement are independent: an item can sit in a project AND a collection at once. Moving an item into a collection changes collection_id only.

  • collection_id is REQUIRED (the key must be present; omitting it is a 400). Pass the current id to keep the item in its collection, a different id to move it, or null (or 0) to move it to the loose reference library.

  • project_id: omit it to leave the item's project exactly as it is. Pass a project id to move it to that project. Pass null ONLY when the user asked to take the item out of its project.

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. Omit to leave the project unchanged; a project id moves the item there; null detaches it (only when the user asked).

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.

Inputs: collection_id (required), context_item_id (required), name, content, +3 more. Returns: id, name, content, link_url, +7 more

update_planA
DestructiveIdempotent
Inspect

Partial 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.

Inputs: plan_uuid (required), title, prompt, due_date, +10 more. Returns: id, stage, title, prompt, +21 more

update_playbookA
DestructiveIdempotent
Inspect

Edit 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.

Inputs: playbook_id (required), name, items, visibility, +2 more. Returns: id, name, items, team_id, +7 more

update_projectA
DestructiveIdempotent
Inspect
Use 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".

Inputs: project_id (required), name, status, visibility, +1 more. Returns: message, project, success

update_workflowA
DestructiveIdempotent
Inspect

Partial update of a workflow template: only the keys you send change; everything else is preserved. Call get_workflow first to see the current state, then send the minimal diff.

Fields: workflow_id (UUID, required); name / description / steps / inputs / allowed_tools / tags as partial overrides; status: "active" | "inactive" | "archived" ("archived" is a soft delete).

Only set status: "active" when the user has actually asked for it. A workflow the user has not approved stays Inactive.

This tool cannot edit a schedule, and it fails silently: a schedule or schedule_config field is ignored, no error is raised and you get a normal success response. Editing a schedule, and turning it On or Paused, happen only in the Marcora app; direct the user there.

Two switches, two vocabularies, never mixed. The workflow's status is Active or Inactive. Its schedule, if any, is On or Paused. Never call a schedule "active"/"inactive" or a workflow "paused"/"on". Active does not mean running; it means the workflow is allowed to run. It runs on its own only when it is Active AND its schedule is On. Setting status: "active" does not turn a Paused schedule On; that takes Resume schedule in the app. Setting it Inactive keeps the schedule as it was: a schedule that was On fires again once the workflow is Active.

When this call changes the status, the response carries a next_step stating what will and won't run afterwards, computed from the saved schedule. Follow it and describe the state that exists after this call. After you set it Active, never tell the user it is Inactive or that they still need to activate it.

Present link_url exactly as returned.

What actually runs needs BOTH switches; describe the pair that exists when you finish:

  • Inactive → nothing runs, by any route (manual runs are refused too).

  • Active, no schedule → runs only when started manually; never starts by itself.

  • Active, schedule Paused → manual runs work; it won't run on its schedule until the user turns the schedule on with Resume schedule in the app.

  • Active, schedule On → runs on its schedule.

  • Inactive, schedule On → nothing runs until the workflow is set Active.

Usage patterns:

  • To set Active: {workflow_id: "", status: "active"}.

  • To set Inactive: {workflow_id: "", status: "inactive"}.

  • To soft-delete: {workflow_id: "", status: "archived"}.

  • To rename: call get_workflow first, then send just {workflow_id, name}.

Links: copy link_url character for character. Never retype, shorten, or rebuild a link or the IDs inside it.

Inputs: workflow_id (required), name, tags, steps, +4 more. Returns: id, name, tags, steps, +7 more

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      MCP server that connects AI agents to a shared organizational knowledge base, allowing them to query company-specific context like pricing, team, and strategy.
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      MCP server that provides a portable personal knowledge layer for AI tools, enabling cross-LLM continuity and personalized context across clients like Claude, ChatGPT, and Cursor.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Standardize Context, Not Intelligence. An open protocol and native MCP server for preserving, organizing, and serving structured project context (architecture, decision logs, domain rules, and roadmap) to AI coding assistants (Cursor, Claude Desktop, Antigravity) with built-in CLI verification
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that connects Claude.ai to a Notion-based marketing knowledge base, enabling search and retrieval across specialized domains like enterprise platforms and competitive positioning. It provides tools for RAG-style Q\&A and content browsing to assist with drafting RFPs and value propositions.
      1
      -
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources