# Wiki.js MCP MCP

> Wiki.js MCP connects your AI agent directly to your internal knowledge base. You can manage documentation by creating new pages, updating existing content, deleting outdated docs, and searching across every page instantly—all without opening a browser or writing API calls.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** documentation, wiki, content-creation, knowledge-base, api-access

## Description

Need to structure or update technical guides? This connector gives your AI agent full control over your Wiki.js instance. Instead of navigating multiple tabs or exporting data just to hand it off to someone else, your agent talks directly to the knowledge base. It can list every page you have, search for a specific concept across all content, and even create brand new sections with metadata attached. You'll stop treating documentation like static files and start treating it like live, editable data.

If you run complex operations involving multiple internal systems—say, pulling customer records from one source and updating the corresponding guide in another—you can chain these tools together using Vinkius. Since your credentials pass through a zero-trust proxy, your keys never sit on disk, keeping your sensitive documentation safe while automating massive workflows.

## Tools

### create_page
Generates and publishes a brand new documentation page within your wiki instance.

### delete_page
Removes an entire document from the knowledge base, marking it as deleted.

### get_page
Retrieves all content and metadata for a specific page using its unique path.

### list_pages
Provides a full inventory of every available page title in the wiki.

### search_pages
Searches the content and metadata across all pages for specified keywords or phrases.

### update_page
Modifies the text, title, or status of an existing page using its ID.

## Prompt Examples

**Prompt:** 
```
Search for 'deployment guide' in our Wiki.js.
```

**Response:** 
```
I found 2 pages matching 'deployment guide': 'Infrastructure/Deployment' (path: infra/deploy) and 'CI-CD/Production-Guide' (path: cicd/prod). Would you like me to fetch the content of one of them?
```

**Prompt:** 
```
Create a new markdown page at 'docs/api-v2' titled 'API v2 Reference'.
```

**Response:** 
```
I've created the page 'API v2 Reference' at the path 'docs/api-v2'. It is currently published and set to markdown format. You can now add content to it using the update tool.
```

**Prompt:** 
```
List all the pages available in our wiki.
```

**Response:** 
```
I've retrieved the list of pages. You have 15 pages in total, including 'Home', 'Onboarding', 'API-Docs', and 'Security-Policy'. Which one would you like to inspect?
```

## Capabilities

### Discover all content
List every single page available in the wiki to understand the scope of your knowledge base.

### Search specific topics
Run precise searches across the entire documentation library using keywords or phrases.

### Fetch content by path
Retrieve the complete text and metadata for a page when you know its exact URL structure.

### Write new pages
Generate and publish entirely new documentation articles with full formatting and metadata.

### Revise existing content
Modify the text or details of a page using its unique identifier without losing historical context.

### Remove outdated pages
Delete documentation that is no longer accurate, keeping your knowledge base clean and current.

## Use Cases

### Onboarding new engineers
A new engineer needs the setup guide, but it's spread across three different documents. The agent runs `list_pages`, finds all 'onboarding' content, and compiles a single summary of key steps by pulling data from multiple sources using `get_page`.

### Updating compliance requirements
Compliance mandates change the privacy policy. Instead of manually finding every mention, the agent runs a targeted search with `search_pages`, identifies all relevant guides, and then uses `update_page` to apply the new text across the board.

### Auditing content accuracy
The team suspects old documentation is misleading. The agent runs `list_pages` to get a full inventory, flags pages with low traffic metadata, and helps prune them by running `delete_page` on the oldest guides.

### Creating API reference docs
A developer finished a new microservice. They tell their agent to generate an initial guide. The agent uses `create_page` to build the skeleton, then uses `get_page` and `update_page` iteratively until the documentation is complete.

## Benefits

- Stop manually searching the GUI. If you need to find a guide, simply ask your agent and let it run `search_pages` across millions of words instantly.
- Never lose content or struggle with versioning again. You can use `get_page` by its exact path to guarantee you are working on the correct source material every time.
- Build automated documentation workflows. Combine this MCP with a ticketing system MCP—when an issue is logged, your agent can automatically pull details and draft a new page using `create_page`.
- Keep your knowledge base clean. Instead of manually reviewing content for staleness, use `list_pages` to audit the structure and then run `delete_page` on guides that haven't been touched in years.
- Save time writing repetitive docs. Use `update_page` to modify a single section (like legal disclaimers) across multiple related pages simultaneously.

## How It Works

The bottom line is, you tell your agent what needs doing, and it executes the necessary steps directly against your wiki.

1. Subscribe to this MCP and input your Wiki.js API URL and key.
2. Your agent connects using the secure Vinkius platform, which handles all authentication in transit.
3. You prompt your AI client with a natural language request (e.g., 'Find documentation on X' or 'Create a page about Y').

## Frequently Asked Questions

**How do I find a page using the Wiki.js MCP? Should I use `get_page` or `search_pages`?**
`Search_pages` is for finding topics across many pages, while `get_page` requires you to know the exact URL path of one specific document.

**Can I automate deleting old wiki content using delete_page?**
Yes. You can set up a workflow that uses your agent to list pages via `list_pages`, filter them for age, and then execute `delete_page` on the identified outdated documents.

**What if I need to modify content but don't know the page ID? Should I use update_page?**
No. You should first run `get_page` or `search_pages` to find the correct path and metadata, which will provide the necessary identifiers for `update_page`.

**Is there a tool to list all pages in the Wiki.js MCP?**
Yes, use `list_pages`. This function provides a complete inventory of every page title and path, letting you audit your entire knowledge base structure at a glance.

**When I use `get_page`, how do I fetch content written in a specific language or locale?**
You must provide both the URL path and the required locale code when calling `get_page`. The tool uses this pairing to pull the correct, localized version of the raw content and metadata.

**If I use `update_page`, how do I control whether a page is published or kept as a private draft?**
You specify the desired publishing status directly in the update payload. This lets you manage visibility, ensuring content is live, published, or restricted to internal drafts before calling `update_page`.

**Does `create_page` allow me to set initial metadata like a page owner or category tags?**
Yes, you include a full metadata payload when running `create_page`. This ensures the new documentation is correctly attributed and categorized right from its initial creation.

**What happens if I run `list_pages` but only have read-only access to the wiki?**
The tool respects your API key's defined scope. If you lack directory listing permissions, the call will fail or return an empty set of results, protecting unauthorized discovery.

**Can I search for specific keywords across all my wiki pages?**
Yes! Use the `search_pages` tool with your query string. The agent will scan all content and return relevant page matches including titles and paths.

**How do I fetch the content of a specific page if I have the URL path?**
Use the `get_page` tool. Simply provide the path (e.g., 'home' or 'engineering/setup') and the agent will retrieve the full content and metadata for that specific page.

**Is it possible to modify an existing page's content?**
Absolutely. Use the `update_page` tool by providing the unique page ID and the new content or title you wish to apply. The agent will handle the update via the Wiki.js API.