# Choose an extension

CKEditor AI reads and edits HTML documents without any extension. Extensions make it work with your material, your systems, and your models: give it your style guide and glossary, let it query your knowledge base during a chat, run it on models in your own cloud tenant, or send every chat message to your own service first.

This page helps you pick the extension for your case. Contexts and skills change what the agent knows. Model providers let the agent run on models from your own accounts. MCP tools let the agent reach your systems, and hooks call your service while the agent answers a chat message.

To learn how a turn runs and where extensions plug in, see [How CKEditor AI works](../how-it-works.md).

Start with the [Context library](context-library.md). It holds the style guide and reference material that users otherwise paste into every request.

<a id="extensions">

## Extensions

Each card links to the page for one extension.

[](context-library.md)[](model-providers.md)[](mcp-tools.md)[](hooks.md)[](skills.md)

<a id="match-extensions-to-your-goal">

## Match extensions to your goal

The table pairs a problem with the extension that solves it.

| Extension                                 | What it does                                                                                                  | When to use it                                                                                                              | Example                                                                                                                                                                                                                                                  |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **[Context library](context-library.md)** | Reusable prompts and files stored in your environment, referenced by id or applied automatically to a feature | The same rules or reference material should ground every request                                                            | A brand-voice prompt and a glossary applied to every “Fix grammar” action. See [Check drafts against your style guide](../apply-your-style-guide.md)                                                                                                     |
| **[Model providers](model-providers.md)** | Runs the agent on models from your own account, cloud tenant, or hardware                                     | Prompts and document content must stay with a provider you control, or all LLM traffic must go through your company gateway | Point the service at your own Azure OpenAI deployment, Bedrock account, or OpenAI-compatible gateway                                                                                                                                                     |
| **[MCP tools](mcp-tools.md)**             | Tools the agent can call while it works, served by your MCP server                                            | Your knowledge base is too large to put in a context, so the agent should query it for what a request needs                 | An advisor asks for the key findings on a deal. The agent queries your database and writes the findings into the report. See [Fetch data from your systems](../fetch-data-from-your-systems.md)                                                          |
| **[Hooks](hooks.md)**                     | An HTTPS endpoint you host, called at fixed points while the agent answers a chat message                     | Your own agent decides for each chat message whether to answer it or hand it to our agent                                   | Your agent answers a request to run a compliance check itself, and hands a request to reword a clause to our agent. See [Extend your agent’s capabilities](../extend-your-agent.md) and [Moderate content with your own rules](../content-moderation.md) |
| **[Skills](skills.md)**                   | Knowledge of the markup behind a specific editor feature                                                      | Nothing to set up. The agent writes the markup of the CKEditor 5 features your editor enables                               | Asked for a footnote, the agent writes the markup the footnotes plugin reads, and the editor keeps it                                                                                                                                                    |

Model providers and hooks are available on on-premises deployments only. The other extensions work on SaaS and on-premises.

<a id="compare-extensions">

### Compare extensions

Some extensions overlap. The tabs show how to tell them apart.

**Contexts vs MCP tools**

| Aspect               | Contexts                                       | MCP tools                                   |
| -------------------- | ---------------------------------------------- | ------------------------------------------- |
| **What it provides** | Prompts and files the agent reads              | Tools the agent calls                       |
| **Lives in**         | Your environment, managed through the REST API | Your MCP servers, connected per environment |
| **Example**          | A brand guidelines PDF                         | A search of the company’s knowledge base    |

**Use a context** when the material is stable and every request should see it.

**Use an MCP tool** when the agent must look something up or act at the moment of the request.

**Contexts vs Skills**

Skills are built in and cover the editor’s markup. Use a context for anything about your content.

| Aspect              | Contexts                                      | Skills                                      |
| ------------------- | --------------------------------------------- | ------------------------------------------- |
| **When it loads**   | On every request it is attached or applied to | When the agent needs it for the task        |
| **Knowledge about** | Your content: style, policies, terminology    | The editor: the markup a feature produces   |
| **Room for**        | Short material that must always be present    | Larger detail that is only needed sometimes |

**Use a context** for what the agent must know on every request: how you write, which terms to use, what must never be said. Keep it short, because every request pays for it.

**A skill** loads only when the document calls for its feature, so it holds more detail than a context without every request paying for it. You do not attach or configure skills.

**Hooks vs MCP tools**

Both call your infrastructure while the agent answers a chat message. They differ in who is in charge and when it is called.

| Aspect                            | Hooks                                              | MCP tools                                               |
| --------------------------------- | -------------------------------------------------- | ------------------------------------------------------- |
| **Who calls whom**                | We call your endpoint at a fixed point in the turn | The agent decides to call a tool when the task needs it |
| **Determinism**                   | Fires on every matching turn                       | The agent chooses, so the outcome can vary              |
| **Can refuse or answer the turn** | Yes                                                | No                                                      |

**Use a hook** when your system must stay in control of our agent.

**Use MCP tools** when the agent should decide when to reach out and what to do with the result.

**Hooks vs Model providers**

Both bring something of yours into the turn. They differ in whose agent loop runs.

| Aspect                    | Hooks                                                                         | Model providers                                      |
| ------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------------------- |
| **Whose agent loop runs** | Yours first. We call your agent, which does its own work and returns a result | Ours, unchanged                                      |
| **What is yours in it**   | The whole agent: its loop, its tools, its custom operations                   | The models only                                      |
| **How the two connect**   | Agent to agent, over an HTTPS endpoint you host                               | Our agent calls your models where it would call ours |
| **Our agent**             | Runs only if your agent hands the turn over                                   | Runs every request                                   |

**Use a hook** when you already have an agent with its own loop and custom operations. It cannot be plugged into our agent directly, so the hook calls it first and lets it decide what comes back. See [Extend your agent’s capabilities](../extend-your-agent.html).

**Use a model provider** when what you have is models: fine-tuned, hosted on your infrastructure, or behind your company gateway. Our agent keeps doing the work, on your models.

Use both when your agent must own the decisions and the reasoning must stay on your models.

<a id="combine-extensions">

### Combine extensions

One request often needs more than one extension. An analyst asks for the findings on a deal. The agent must know your markup, reach your data, and write in your voice. Each of those is a different extension. The pairs below come up most often. For a backend job that combines a context with MCP tool checks, see [Edit documents from your backend](../verify-with-your-tools.md).

| Pattern                    | How it works                                                                                                                                          | Example                                                                                                             |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| **Skill + MCP tools**      | The skill tells the agent which markup the editor accepts. The tool gives the agent the data to put in that markup                                    | The agent pulls the key findings on a deal from your database and writes them into a table the editor accepts       |
| **Context + MCP tools**    | A context copied from your wiki goes stale. Load its files from an MCP resource instead, and the agent reads what your wiki publishes today           | Your policy wiki is the house-style context, and the same server answers lookups during a turn                      |
| **Hook + Context**         | Your agent knows facts about the user and the task that our agent does not. Your agent attaches those facts as context when it hands the message over | Your agent recognizes which client the analyst is working for and passes that client’s terms before our agent edits |
| **Hook + Model providers** | Your agent decides each chat message. When our agent runs, it reasons on your models                                                                  | Every message goes through your agent first, and every model call goes through the company gateway                  |

<a id="next-steps">

## Next steps

* **[LLM providers](../../../onpremises/ckeditor-ai-onpremises/llm-providers.md)** covers the `providers` and `models` options of an on-premises deployment: the providers the service connects to, the models it offers to users, and agent models.
* **[Hooks](../../../onpremises/ckeditor-ai-onpremises/hooks.md)** covers the hook endpoint: its configuration, the request your endpoint receives, how calls are signed, and the decisions it can return.
* **[MCP tools](../../../onpremises/ckeditor-ai-onpremises/mcp-tools.md)** covers how to define servers in an on-premises deployment instead of through the admin API: authentication, which tools are exposed, and which environments can use a server.
* **[Permissions](../permissions.md)** covers the `ai:admin` scope you need to manage contexts and MCP servers, and the `ai:contexts` scopes that gate individual contexts.

---

Full index of the Cloud Services documentation: [llms.txt](../../../../llms.txt)