> For the complete documentation index, see [llms.txt](https://developer.frontitude.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.frontitude.com/mcp/tool-reference.md).

# Tool reference

Ask for what you want and your agent picks the tool from the groups below. You never name a tool yourself. [Examples](/mcp/examples.md) shows the wording that works.

Frontitude's tools fall into the groups below. Your agent only sees the ones your connection allows: a read-only connection gets the read group alone, and the tool picker narrows it further from there. `frontitude_ping` isn't in the picker, so it stays on every connection. Your agent gets the full details of each tool straight from Frontitude, so we've kept this page to a one-line summary each.

## Read your content

| Tool                                  | What it does                                                                                                                     |
| ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `frontitude_ping`                     | Checks the connection works and reports which workspace it's signed in to.                                                       |
| `frontitude_get_component`            | Opens one component in full, with its history, translations and comments.                                                        |
| `frontitude_get_text`                 | Opens one text in full, with its history, translations and design context.                                                       |
| `frontitude_count_scope`              | Counts what's in the library, a category, a project, a page or a frame.                                                          |
| `frontitude_list_components`          | Lists components in a category or across the library, with filters.                                                              |
| `frontitude_list_component_instances` | Lists the texts using a component, with the project, page and frame each sits in.                                                |
| `frontitude_list_texts`               | Lists the texts in a project, page, frame or the whole workspace, with filters.                                                  |
| `frontitude_list_scopes`              | Turns a name into the id the other tools need, for any place, tag, variable or language.                                         |
| `frontitude_get_project_structure`    | Returns a project's pages and frames, with a text count per status in each. Use it when you need the layout, not only the total. |
| `frontitude_search_components`        | Finds components in the copy library by meaning rather than exact wording.                                                       |

## Change your content

| Tool                                   | What it does                                                                                                                                                                                                    |
| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `frontitude_update_component_values`   | Writes the copy of one or more components in a single language.                                                                                                                                                 |
| `frontitude_update_component_metadata` | Renames components, or sets their note or character limit, never the copy.                                                                                                                                      |
| `frontitude_move_components`           | Files components under a library category, or uncategorizes them.                                                                                                                                               |
| `frontitude_update_text_values`        | Writes the copy of texts in a project, one language at a time. Copy that matches an existing component attaches the text to that component. The call refuses a text whose component is used by other texts too. |
| `frontitude_set_text_hidden`           | Takes texts out of the project's text list, or puts them back.                                                                                                                                                  |
| `frontitude_set_status`                | Moves components or texts to New, Draft, In Review or Final, one language at a time.                                                                                                                            |
| `frontitude_update_tags`               | Adds workspace tags to components or texts, and removes them again.                                                                                                                                             |
| `frontitude_set_unique_key`            | Gives components the developer keys that exports and the CLI use.                                                                                                                                               |
| `frontitude_set_variable_placeholder`  | Chooses which of a variable's example values one component or text shows in the app, display only. It doesn't change the variable itself.                                                                       |
| `frontitude_set_selected_plural`       | Chooses which plural form a component or instance shows in a language.                                                                                                                                          |
| `frontitude_upsert_category`           | Creates a library category, renames one, or sets the note on it.                                                                                                                                                |
| `frontitude_manage_tag`                | Creates a workspace tag, or relabels one that already exists.                                                                                                                                                   |
| `frontitude_manage_variable`           | Creates a variable, renames one, or adds and renames the example values it offers.                                                                                                                              |
| `frontitude_rename_scope`              | Renames a project or a project folder, leaving the contents alone.                                                                                                                                              |
| `frontitude_add_comment`               | Posts a comment on a component or text, or replies in a thread. Nobody is emailed.                                                                                                                              |

## Remove and reorganize

These are the writes that can take copy away. Creating a component and attaching a text both rewrite the texts they touch, so they sit with the deletes rather than the edits.

| Tool                           | What it does                                                                                                                          |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
| `frontitude_create_components` | Creates components from a value you supply, rewriting any texts it converts to that value.                                            |
| `frontitude_attach_texts`      | Makes texts instances of a component, so they take and follow its value. Moving a text between components goes through the same call. |
| `frontitude_detach_texts`      | Cuts texts loose from their components. Each keeps only its source-language value.                                                    |
| `frontitude_delete_components` | Deletes components and every revision they hold, detaching texts first.                                                               |
| `frontitude_delete_category`   | Deletes a library category and its subcategories, and either keeps or deletes their components.                                       |
| `frontitude_delete_tag`        | Deletes a workspace tag and strips it from everything carrying it.                                                                    |
| `frontitude_delete_variable`   | Deletes a variable, or removes one of the example values it offers.                                                                   |
| `frontitude_remove_plurals`    | Deletes one plural form of a component, or turns plural forms off.                                                                    |
| `frontitude_move_project`      | Moves a project into a project folder, or out to the top level.                                                                       |

## What's guarded, and what can't be undone

`frontitude_create_components` takes `isDryRun`. It runs the same checks the real call runs, reports what would happen, and writes nothing.

The guards below make your agent say what it expects before a write runs. If what it says is wrong the server refuses the call and reports the truth, so a write that reaches further than your agent expected fails instead of running. These guards cover the calls listed below and nothing else.

* `expectedAffectedCount` is how many items the call changes. `frontitude_delete_components`, `frontitude_delete_category` and `frontitude_delete_tag` always take it. `frontitude_delete_variable` takes it when it deletes the whole variable rather than one example value, and `frontitude_manage_variable` when it renames the variable or one of its values.
* `acknowledgedInstances` is how many texts a component write touches. `frontitude_update_component_values` takes it when a component in the call is used by more than one text, because writing the component writes every text using it.
* `expectedValue` is the copy your agent read. Send it with an item of `frontitude_update_component_values` or `frontitude_update_text_values` and Frontitude refuses the call if somebody changed that copy first.

{% hint style="warning" %}
Confirm the list before any delete. A delete can't be undone. `frontitude_delete_components` and `frontitude_delete_category` take their contents with them, edit history included. `frontitude_delete_variable` rewrites every value that used the variable into literal text. `frontitude_remove_plurals` takes the values of the removed forms with it, whether it drops one form or turns plurals off.
{% endhint %}

Some writes have a bigger impact than their names suggest. Rename a variable through `frontitude_manage_variable` and it rewrites every component and text using it, drops each one back to Draft, and flags its translations for review. A move to Final in the source language starts auto-translation, if your workspace has it on, which spends your [translation allowance](/mcp/limits-and-errors.md). An unattached text moved to Final also gets a component created for it, which counts against your plan. An editor or an admin can turn that off under ***Copy components*** on the [***Data Management*** tab](https://app.frontitude.com/settings/data?utm_source=mcp-docs).

Attach and detach change what a text holds. A text that joins a component gives up the developer key it had, and reports the component's key from then on. A text that leaves keeps only its source-language value, because the translations and the key it was showing belong to the component. Neither move undoes the other.

Writes are safe to repeat. If a call would leave something exactly as it already is, Frontitude writes nothing: no new entry in its edit history, and no webhook. When a call covers several items and one of them fails, the rest still land and the response says which item failed and why.

{% hint style="warning" %}
Watch `frontitude_move_project`. Some collaborators can see a project only because they have access to its folder. Move the project out and they lose it.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://developer.frontitude.com/mcp/tool-reference.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
