Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP-Kanka find all characters in my campaign with the 'villain' tag"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP (Model Context Protocol) server for Kanka API integration. This server provides AI assistants with tools to interact with Kanka campaigns, enabling CRUD operations on various entity types like characters, locations, organizations, and more.
This package is designed specifically to serve the needs of Teghrim but may be useful to others working with Kanka and MCP.
Entity Management: Create, read, update, and delete Kanka entities
Search & Filter: Search entities by name with partial matching, filter by type/tags/date
Batch Operations: Process multiple entities in a single request
Posts Management: Create, update, and delete posts (notes) on entities
Markdown Support: Automatic conversion between Markdown and HTML with entity mention preservation
Type Safety: Full type hints and validation
Client-side Filtering: Enhanced filtering beyond API limitations
Sync Support: Efficient synchronization with timestamp tracking and Kanka's native lastSync feature
Timestamp Tracking: All entities include created_at and updated_at timestamps
Related MCP server: kanka-mcp
Python 3.10 or higher (3.13.5 recommended)
Kanka API token and campaign ID
pip install mcp-kankagit clone https://github.com/ervwalter/mcp-kanka.git
cd mcp-kanka
uv sync --all-groups
uv pip install -e .git clone https://github.com/ervwalter/mcp-kanka.git
cd mcp-kanka
pip install -e .Set up your environment variables:
KANKA_TOKEN: Your Kanka API token
KANKA_CAMPAIGN_ID: Your campaign ID
Add to Claude Desktop config:
{
"mcpServers": {
"kanka": {
"command": "python",
"args": ["-m", "mcp_kanka"],
"env": {
"KANKA_TOKEN": "your-token",
"KANKA_CAMPAIGN_ID": "your-campaign-id"
}
}
}
}claude mcp add kanka \
-e KANKA_TOKEN="your-token" \
-e KANKA_CAMPAIGN_ID="your-campaign-id" \
-- python -m mcp_kankaCharacter - Player characters (PCs), non-player characters (NPCs)
Creature - Monster types, animals, non-unique creatures
Location - Places, regions, buildings, landmarks
Organization - Guilds, governments, cults, companies
Race - Species, ancestries
Note - Internal content, session digests, GM notes (private by default)
Journal - Session summaries, narratives, chronicles
Quest - Missions, objectives, story arcs
find_entitiesSearch and filter entities with comprehensive options and sync metadata.
Parameters:
entity_type (optional): Type to filter by - character, creature, location, organization, race, note, journal, quest
query (optional): Search term for full-text search across names and content
name (optional): Filter by name (partial match by default, e.g., "Test" matches "Test Character")
name_exact (optional): Use exact name matching instead of partial (default: false)
name_fuzzy (optional): Enable fuzzy matching for typo tolerance (default: false)
type (optional): Filter by user-defined Type field (e.g., 'NPC', 'City')
tags (optional): Array of tags - returns entities having ALL specified tags
date_range (optional): For journals only - filter by date range with start and end dates
limit (optional): Results per page (default: 25, max: 100, use 0 for all)
page (optional): Page number for pagination (default: 1)
include_full (optional): Include full entity details (default: true)
last_synced (optional): ISO 8601 timestamp to get only entities modified after this time
Returns:
{
"entities": [...],
"sync_info": {
"request_timestamp": "2024-01-01T12:00:00Z",
"newest_updated_at": "2024-01-01T11:30:00Z",
"total_count": 150,
"returned_count": 25
}
}create_entitiesCreate one or more entities with markdown content.
Parameters:
entities: Array of entities to create, each with:
entity_type (required): Type of entity to create
name (required): Entity name
entry (optional): Description in Markdown format
type (optional): User-defined Type field (e.g., 'NPC', 'Player Character')
tags (optional): Array of tag names
is_hidden (optional): If true, hidden from players (admin-only)
Returns: Array of created entities with their IDs and timestamps
update_entitiesUpdate one or more existing entities.
Parameters:
updates: Array of updates, each with:
entity_id (required): ID of entity to update
name (required): Entity name (required by Kanka API even if unchanged)
entry (optional): Updated content in Markdown format
type (optional): Updated Type field
tags (optional): Updated array of tags
is_hidden (optional): If true, hidden from players (admin-only)
Returns: Array of results with success/error status for each update
get_entitiesRetrieve specific entities by ID with optional posts.
Parameters:
entity_ids (required): Array of entity IDs to retrieve
include_posts (optional): Include posts for each entity (default: false)
Returns: Array of full entity details with timestamps and optional posts
delete_entitiesDelete one or more entities.
Parameters:
entity_ids (required): Array of entity IDs to delete
Returns: Array of results with success/error status for each deletion
check_entity_updatesEfficiently check which entities have been modified since last sync.
Parameters:
entity_ids (required): Array of entity IDs to check
last_synced (required): ISO 8601 timestamp to check updates since
Returns:
{
"modified_entity_ids": [101, 103],
"deleted_entity_ids": [102],
"check_timestamp": "2024-01-01T12:00:00Z"
}create_postsAdd posts (notes) to entities.
Parameters:
posts: Array of posts to create, each with:
entity_id (required): Entity to attach post to
name (required): Post title
entry (optional): Post content in Markdown format
is_hidden (optional): If true, hidden from players (admin-only)
Returns: Array of created posts with their IDs
update_postsModify existing posts.
Parameters:
updates: Array of updates, each with:
entity_id (required): The entity ID
post_id (required): The post ID to update
name (required): Post title (required by API even if unchanged)
entry (optional): Updated content in Markdown format
is_hidden (optional): If true, hidden from players (admin-only)
Returns: Array of results with success/error status for each update
delete_postsRemove posts from entities.
Parameters:
deletions: Array of deletions, each with:
entity_id (required): The entity ID
post_id (required): The post ID to delete
Returns: Array of results with success/error status for each deletion
The MCP server provides enhanced search capabilities:
Content search: Full-text search across entity names and content (client-side)
Name filter: Exact or fuzzy name matching
Type filter: Filter by user-defined type field (e.g., 'NPC', 'City')
Tag filter: Filter by tags (AND logic - entity must have all specified tags)
Date range: Filter journals by date
Fuzzy matching: Optional fuzzy name matching for more flexible searches
Last sync filter: Use Kanka's native lastSync parameter to get only modified entities
Note: Content search fetches all entities and searches client-side, which may be slower for large campaigns but provides comprehensive search functionality.
All entities include created_at and updated_at timestamps in ISO 8601 format, enabling:
Tracking when entities were created or last modified
Implementing conflict resolution strategies
Building audit trails
The find_entities tool returns sync metadata including:
request_timestamp: When the request was made
newest_updated_at: Latest updated_at from returned entities
total_count: Total matching entities
returned_count: Number returned in this response
Use the last_synced parameter to fetch only entities modified after a specific time:
# Example: Get entities modified in the last 24 hours
result = await find_entities(
entity_type="character",
last_synced="2024-01-01T00:00:00Z"
)The check_entity_updates tool efficiently checks which entities have been modified:
# Check which of these entities have changed
result = await check_entity_updates(
entity_ids=[101, 102, 103],
last_synced="2024-01-01T00:00:00Z"
)
# Returns: modified_entity_ids, deleted_entity_ids, check_timestamp# Clone the repository
git clone https://github.com/ervwalter/mcp-kanka.git
cd mcp-kanka
# Install development dependencies
make install# Run all tests
make test
# Run with coverage
make coverage
# Run all checks (lint + typecheck + test)
make check# Format code
make format
# Run linting
make lint
# Run type checking
make typecheckIn addition to being an MCP server, this package provides an operations layer that can be used directly in Python scripts:
from mcp_kanka.operations import create_operations
# Create operations instance
ops = create_operations()
# Find entities
result = await ops.find_entities(
entity_type="character",
name="Moradin"
)
# Create an entity
results = await ops.create_entities([{
"entity_type": "character",
"name": "New Character",
"type": "NPC",
"entry": "A mysterious figure"
}])This makes it easy to build sync scripts, bulk operations, or other tools that interact with Kanka.
The MCP server requires:
KANKA_TOKEN: Your Kanka API token
KANKA_CAMPAIGN_ID: The ID of your Kanka campaign
The server provides a kanka://context resource that explains Kanka's structure and capabilities.
Initial release
Full CRUD operations for Kanka entities
Batch operations support
Markdown/HTML conversion with entity mention preservation
Sync support with timestamp tracking
Comprehensive search and filtering capabilities
MIT
Check which entity_ids have been modified since last sync
| Name | Required | Description | Default |
|---|---|---|---|
| entity_ids | Yes | Array of entity IDs to check | |
| last_synced | Yes | ISO 8601 timestamp to check updates since |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions checking for modifications since 'last sync', implying a read-only operation focused on change detection, but doesn't specify whether it returns all modifications, only recent ones, or details like error handling or rate limits. For a tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, making it easy to parse quickly. Every part of the sentence contributes essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete for a tool that likely returns modification data. It doesn't explain what the output includes (e.g., list of modified IDs, timestamps, or changes), nor does it cover behavioral aspects like error cases or performance. For a tool with two required parameters and no structured output, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with both parameters ('entity_ids' and 'last_synced') fully documented in the input schema. The description adds minimal value beyond the schema by implying the tool checks modifications for given IDs since a timestamp, but it doesn't provide additional context like format examples or usage nuances. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as checking which entity_ids have been modified since a specific timestamp. It uses specific verbs ('check', 'modified') and identifies the resource ('entity_ids'), making the action clear. However, it doesn't explicitly differentiate from sibling tools like 'find_entities' or 'get_entities', which might also retrieve entity information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites like requiring a previous sync timestamp, nor does it compare to sibling tools such as 'find_entities' or 'get_entities' that might serve similar purposes. This leaves the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create one or more entities
| Name | Required | Description | Default |
|---|---|---|---|
| entities | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates entities but doesn't mention permissions required, whether creation is reversible, rate limits, or what happens on success/failure. For a mutation tool with zero annotation coverage, this is a significant gap in transparency about its operational behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a single sentence 'Create one or more entities'. It's front-loaded and wastes no words, making it easy to parse quickly. Every word earns its place by conveying the core action and resource without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of creating entities with multiple nested properties, no annotations, and no output schema, the description is incomplete. It doesn't explain the entity types, required fields, or what the tool returns, leaving significant gaps for the agent to infer from the schema alone. This is inadequate for a tool with such rich input structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description has 0% schema description coverage, but it compensates by implying the 'entities' parameter is an array of objects to create. However, it doesn't detail the structure or required fields beyond what the schema provides. Since there's only 1 parameter, the baseline is high, but the description adds minimal semantic value beyond the schema's explicit properties and enums.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Create one or more entities' clearly states the action (create) and resource (entities), but it's vague about what 'entities' are in this context. It doesn't distinguish this tool from sibling tools like 'create_posts' or explain what types of entities can be created, leaving the purpose somewhat ambiguous despite having a basic verb+resource structure.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'update_entities' or 'delete_entities', nor does it specify prerequisites, contexts, or exclusions for creation. This lack of comparative context leaves the agent without clear usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create posts on entities
| Name | Required | Description | Default |
|---|---|---|---|
| posts | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create posts' which implies a write operation, but doesn't mention permissions, side effects, error handling, or response format. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with just three words, front-loaded with the core action. There's no wasted language, though this brevity contributes to the lack of detail in other dimensions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 1 parameter (a complex array of objects), 0% schema coverage, no annotations, and no output schema, the description is completely inadequate. It doesn't explain what 'posts' or 'entities' are, how creation works, or what to expect in return.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning all parameters are undocumented in the schema. The description adds no information about the 'posts' parameter or its nested properties (entity_id, name, entry, is_hidden), failing to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Create posts on entities' states the basic action (create) and target (posts on entities), but it's vague about what 'posts' and 'entities' mean in this context. It doesn't distinguish this tool from sibling tools like 'create_entities' or 'update_posts', leaving the scope unclear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'update_posts' or 'create_entities'. The description lacks any context about prerequisites, timing, or exclusions, offering no help for tool selection among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete one or more entities
| Name | Required | Description | Default |
|---|---|---|---|
| entity_ids | Yes | Array of entity IDs to delete |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the destructive action ('delete') but lacks critical details: whether deletion is permanent or reversible, required permissions, rate limits, error handling, or what happens to associated data. For a mutation tool with zero annotation coverage, this is a significant gap in safety and operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with zero wasted words. It's front-loaded with the core action and target, making it highly efficient. Every word earns its place, adhering perfectly to conciseness principles.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a destructive mutation), lack of annotations, and no output schema, the description is incomplete. It fails to address critical aspects like return values, error conditions, or behavioral nuances, leaving the agent under-informed for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'entity_ids' documented as 'Array of entity IDs to delete'. The description adds no additional meaning beyond this, such as format examples, ID sourcing, or validation rules. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Delete one or more entities' clearly states the action (delete) and target (entities), making the purpose immediately understandable. It distinguishes from siblings like 'create_entities' or 'update_entities' by specifying deletion. However, it doesn't clarify what 'entities' represent in this context, which keeps it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing entity IDs from 'get_entities' or 'find_entities'), exclusions (e.g., not for posts, which have separate delete tools), or consequences of deletion. This leaves the agent to infer usage from sibling names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete posts from entities
| Name | Required | Description | Default |
|---|---|---|---|
| deletions | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool deletes posts, implying a destructive mutation, but doesn't mention permissions required, whether deletions are permanent or reversible, error handling, or any rate limits. This leaves critical behavioral traits unspecified for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words, making it appropriately concise. However, it's overly brief given the tool's destructive nature and lack of other documentation, which could be seen as under-specification rather than ideal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature, no annotations, no output schema, and 0% schema coverage, the description is incomplete. It doesn't explain what happens after deletion, return values, error conditions, or how it interacts with sibling tools. More context is needed for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning parameters are undocumented in the schema. The description adds no information about the 'deletions' parameter, such as what it contains, how to structure deletions, or examples of usage. It fails to compensate for the lack of schema documentation, leaving parameters semantically unclear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Delete posts from entities' clearly states the action (delete) and target (posts from entities), which is better than a tautology. However, it doesn't specify what 'entities' are or differentiate this tool from sibling tools like 'delete_entities' or 'update_posts', leaving the scope somewhat vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'delete_entities' (which might delete entire entities) or 'update_posts' (which might modify posts instead). There's no mention of prerequisites, constraints, or typical use cases, offering minimal context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find entities by search and/or filtering
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | Search term (searches names and content) | |
| entity_type | No | Entity type to filter by | |
| name | No | Filter by name (partial match by default, e.g. 'Test' matches 'Test Character') | |
| name_exact | No | Use exact matching on name filter (case-insensitive) | |
| name_fuzzy | No | Use fuzzy matching on name filter (typo-tolerant) | |
| type | No | Filter by Type field (e.g., 'NPC', 'City') | |
| tags | No | Filter by tags (matches entities having ALL specified tags) | |
| date_range | No | For filtering journals by date | |
| include_full | No | Include full entity details | |
| page | No | Page number for pagination | |
| limit | No | Results per page (default 25, max 100, use 0 for all) | |
| last_synced | No | ISO 8601 timestamp to get only entities modified after this time |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'search and/or filtering' but lacks critical behavioral details: whether this is a read-only operation, how results are returned (e.g., pagination details beyond schema), error conditions, or performance implications. The description is too vague for a tool with 12 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'Find entities by search and/or filtering.' It's front-loaded with the core purpose and wastes no words. Every part earns its place, making it highly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (12 parameters, no annotations, no output schema), the description is inadequate. It doesn't explain return values, error handling, or behavioral nuances. For a search/filter tool with many options, more context is needed to guide effective use, especially without annotations or output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 12 parameters. The description adds no additional parameter semantics beyond implying search/filtering capabilities. This meets the baseline of 3 since the schema does the heavy lifting, but the description doesn't compensate with extra context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Find entities by search and/or filtering.' It specifies the action (find) and resource (entities) with the mechanism (search/filtering). However, it doesn't differentiate from sibling tools like 'get_entities' or 'check_entity_updates,' which likely have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_entities' and 'check_entity_updates,' the agent must guess based on names alone. There's no mention of prerequisites, exclusions, or comparative use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve specific entities by ID with their posts
| Name | Required | Description | Default |
|---|---|---|---|
| entity_ids | Yes | Array of entity IDs to retrieve | |
| include_posts | No | Include posts for each entity |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action 'retrieve' but doesn't cover critical aspects like whether this is a read-only operation, potential rate limits, authentication needs, error handling, or what happens if IDs are invalid. This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, making it easy to grasp quickly with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a retrieval tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'entities' are, what data is returned, how posts are included, or error scenarios. This lack of detail makes it inadequate for an agent to use the tool effectively without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the input schema fully documents both parameters (entity_ids and include_posts). The description adds minimal value by implying retrieval includes posts, but it doesn't provide additional context like format details or usage examples beyond what the schema already specifies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'retrieve' and the resource 'specific entities by ID with their posts', which distinguishes it from siblings like 'find_entities' (likely for searching) or 'create_entities' (for creation). However, it doesn't explicitly contrast with 'check_entity_updates' (which might focus on changes), leaving some ambiguity in sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention scenarios like retrieving known IDs versus searching for entities, or when to include posts, nor does it reference sibling tools like 'find_entities' for broader queries. This lack of context leaves usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update one or more entities
| Name | Required | Description | Default |
|---|---|---|---|
| updates | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers no behavioral details. It does not disclose permissions needed, whether updates are reversible, rate limits, error handling, or what 'update' entails (e.g., partial vs. full updates), making it inadequate for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a single sentence, 'Update one or more entities', which is front-loaded and wastes no words. However, this brevity comes at the cost of clarity and completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a mutation tool with 1 parameter but nested array structure), no annotations, no output schema, and 0% schema coverage, the description is severely incomplete. It fails to provide necessary context for safe and effective use, such as input format, behavioral traits, or output expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but adds no parameter information. It does not explain the 'updates' array structure, required fields like 'name', or the meaning of parameters such as 'entry' or 'is_hidden', leaving all semantics undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Update one or more entities' restates the tool name 'update_entities' with minimal elaboration, making it tautological. It specifies the verb 'update' and resource 'entities' but lacks detail on what entities are or what aspects are updated, failing to distinguish from siblings like 'update_posts' or 'check_entity_updates'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, context, or exclusions, such as when to choose 'update_entities' over 'update_posts' or 'check_entity_updates', leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update existing posts
| Name | Required | Description | Default |
|---|---|---|---|
| updates | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but fails to do so. It does not indicate whether this is a read-only or destructive operation, what permissions are required, potential side effects, or error handling, making it inadequate for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with only three words, front-loaded and free of unnecessary details. However, this conciseness comes at the cost of under-specification, but it earns full marks for brevity and structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of the input schema (with nested objects and multiple required fields), lack of annotations, and no output schema, the description is severely incomplete. It fails to provide necessary context for a mutation tool, leaving critical gaps in understanding behavior and parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate but does not. It mentions no parameters, while the input schema includes a complex 'updates' array with nested objects and required fields like 'entity_id', 'post_id', and 'name'. The description adds no meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Update existing posts' restates the tool name 'update_posts' with minimal elaboration, making it tautological. It specifies the verb ('update') and resource ('posts') but lacks detail about what aspects of posts are updated or how it differs from sibling tools like 'update_entities' or 'create_posts'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, context, or exclusions, such as when to choose 'update_posts' over 'update_entities' or 'create_posts', leaving the agent without usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.1.0check_entity_updatescreate_entitiescreate_postsdelete_entitiesdelete_postsfind_entitiesget_entitiesupdate_entitiesupdate_postsEvery tool has a clearly distinct purpose with no ambiguity: entity operations (create, get, update, delete, find, check updates) and post operations (create, update, delete) are cleanly separated. The descriptions clearly differentiate between working with entities versus posts, and within entities, each action (check updates, find, get, create, update, delete) targets a specific, non-overlapping function.
All tool names follow a consistent verb_noun pattern with snake_case throughout (e.g., create_entities, update_posts). The verbs (check, create, delete, find, get, update) are consistently applied to the appropriate nouns (entities, posts), making the naming highly predictable and readable.
With 9 tools, the count is well-scoped for managing entities and posts in a system like Kanka. Each tool earns its place by covering distinct CRUD operations and additional utilities (like check_entity_updates and find_entities), avoiding bloat while providing comprehensive coverage for the domain.
The tool set offers complete CRUD/lifecycle coverage for both entities and posts, with no obvious gaps. It includes creation, retrieval (get and find), updating, deletion, and synchronization (check updates), ensuring agents can handle all core workflows without dead ends in this domain.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Campaign manager for D&D and TTRPG GMs: your AI reads and writes a live typed campaign database.
Manage Kanera workspaces, boards, cards, checklists, comments, notes, automations, and reports.
Create AI images and videos, manage projects and credits, and use workspace campaign context.
Build, edit and sync Google, Microsoft, Reddit and Meta ad campaigns from your assistant.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ervwalter/mcp-kanka'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
