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.

Start with the Context library. It holds the style guide and reference material that users otherwise paste into every request.

Extensions

Each card links to the page for one extension.

Context library

Reusable prompts and files stored in your environment

Model providers

Models from your own cloud tenant, vendor account, or hardware

MCP tools

Tools the agent calls on your MCP servers

Hooks

An endpoint you host, called at fixed points while the agent answers a chat message

Skills

Knowledge of the markup behind each editor feature

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	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
Model providers	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	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
Hooks	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 and Moderate content with your own rules
Skills	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.

Compare extensions

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

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.

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.

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.

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.

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.

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.

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

Next steps

LLM providers 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 covers the hook endpoint: its configuration, the request your endpoint receives, how calls are signed, and the decisions it can return.
MCP tools 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 covers the ai:admin scope you need to manage contexts and MCP servers, and the ai:contexts scopes that gate individual contexts.