Skip to main content
Glama
Unilytics MCP Server

Unilytics MCP Server

Official

propose_brand_kit

Create or update a client project's Brand Kit as a reviewable draft, citing Knowledge Base documents or user quotes; changes stay unpublished until a consultant approves.

Instructions

Save Brand Kit values for a client project as the Brand Kit's draft, with the sources they come from: brand facts (about, ideal customer profile, point of view, author persona), tone of voice, the call to action, writing rules, content types, writing samples and custom variables. The draft waits on the project's Brand Kit page, where the consultant publishes or discards it; the published Brand Kit, and what get_project_context returns, stay unchanged until then. This tool doesn't publish, discard or delete.

Use when the user asks to add to or update a client's Brand Kit, for example from their brand guidelines.

The changes apply to the published Brand Kit: a field given replaces that field whole; in each list, `remove`
takes items out by id, then `set` adds new items (no id) or replaces an existing item whole (its id). A Brand Kit
that already has a draft waiting for review takes no new proposal, except one that adds to this connection's own
pending proposal (draft_proposal_id). Every proposal cites at least one source: Knowledge Base documents
(`kb_sources`, each with the content_hash kb_get_document returned, which is refused once the document has
changed) and/or the user's own words (`user_statements`, recorded as quotes reported by the AI, not verified).

Args:
    project_id: The project (from list_projects()).
    based_on_version: brand_kit.published_version as get_project_context returned it (0 when there is no
        published Brand Kit). A Brand Kit published again since is refused.
    fields: Fields to replace: about, ideal_customer_profile, point_of_view, author_persona, tone_of_voice (text),
        cta ({text, destination}) and header_case.
    writing_rules: {set, remove}. A rule is {id?, text, content_type_ids}; content_type_ids [] applies it to every
        content type. get_project_context lists the global rules, and a content type's own rules when called
        with that content_type, each with its id and content_type_ids.
    content_types: {set, remove}. A content type is {id?, name, description, cta}; cta is an object, "inherit"
        (the Brand Kit's CTA; the default for a new one) or "none". One named by id states its cta, as
        get_project_context's available_content_types shows it.
    writing_samples: {set, remove}. A sample is {id?, title, url, body, outline}; its current body comes from
        get_project_context with include_samples.
    custom_variables: {set, remove}. A variable is {id?, key, value}; brand_kit.custom_variable_ids gives each
        key's id.
    kb_sources: Knowledge Base documents the values come from: [{document_id, content_hash}].
    user_statements: The user's own words the values come from, quoted exactly.
    draft_proposal_id: The proposal_id (kbp_…) an earlier call returned, to add these changes to that pending
        proposal; a field named here replaces the value that proposal set.
    mutation_id: Optional UUID for this proposal. A repeat with the same mutation_id and arguments returns the
        saved proposal instead of saving another; an OUTCOME_UNKNOWN error names the one it used.

[Provider: Unilytics]

Input Schema

NameRequiredDescriptionDefault
fieldsNo
kb_sourcesNo
project_idYes
mutation_idNo
content_typesNo
writing_rulesNo
user_statementsNo
writing_samplesNo
based_on_versionYes
custom_variablesNo
draft_proposal_idNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv1.1.0

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well past the annotations: it explains that changes land in a draft awaiting consultant review, that the published kit and get_project_context output stay unchanged, the optimistic-concurrency rule on based_on_version (refused if republished), the content_hash refusal once a document changes, that user_statements are unverified quotes, and that remove runs before set. The mutation_id retry behavior is disclosed concretely, including the OUTCOME_UNKNOWN error naming the used id.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose and draft-lifecycle context are front-loaded, then usage, then a per-argument reference, which is the right order for a complex tool. It is long but nearly every sentence carries a rule; the one weakness is mild restatement, e.g. naming the field groups in the opening and again in the fields argument, and 'doesn't publish, discard or delete' repeating the draft framing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an 11-parameter mutation with no output schema and only hint-level annotations, the description covers the lifecycle, the conflict and retry semantics, the source-citation requirement, and the per-list add/replace/remove contract. Return values are not spelled out, but the proposal_id contract is implied through draft_proposal_id, which is sufficient here.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With Top-level schema descriptions essentially absent, the Args block carries the load and adds real meaning beyond structure: based_on_version's provenance and failure mode, content_type_ids [] meaning all types, cta accepting an object or 'inherit'/'none', replace-whole vs add-by-id semantics for every list, and where each id (rul_, cty_, smp_, var_, kbp_) comes from. The mandated citation of at least one source ties kb_sources and user_statements to a hard validation rule.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'Save Brand Kit values for a client project as the Brand Kit's draft', and immediately names the content it carries (brand facts, tone of voice, CTA, writing rules, content types, samples, custom variables). It also draws a hard line against publishing, discarding and deleting, so an agent can distinguish it from the publication step without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit when-to-use ('Use when the user asks to add to or update a client's Brand Kit, for example from their brand guidelines') and explicit when-not ('doesn't publish, discard or delete'), plus the blocking condition that a kit already holding a draft refuses new proposals unless draft_proposal_id extends it. What it lacks is naming the concrete sibling an agent should call instead for publishing or for reading current values, though get_project_context is repeatedly cited as the read source.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server

Other Tools