Context11 MCP Server
Click on "Deploy 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., "@Context11 MCP Serversearch for project requirements"
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.
Context11 MCP Server
An MCP (Model Context Protocol) server that provides access to your Context11 knowledge base for AI assistants.
Installation
npm install context11-mcpRelated MCP server: Convolut MCP Server
Configuration
Environment Variables
Variable | Description | Required |
| Your Context11 API key (starts with | Yes |
| API base URL (default: | No |
Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"context11": {
"command": "npx",
"args": ["-y", "context11-mcp"],
"env": {
"CONTEXT11_API_KEY": "ctx11_your_api_key_here"
}
}
}
}Local Development
For local testing against a development server:
{
"mcpServers": {
"context11": {
"command": "npx",
"args": ["-y", "context11-mcp"],
"env": {
"CONTEXT11_API_KEY": "ctx11_your_api_key_here",
"CONTEXT11_URL": "http://localhost:3000"
}
}
}
}From Source
{
"mcpServers": {
"context11": {
"command": "node",
"args": ["/path/to/context11-mcp/dist/index.js"],
"env": {
"CONTEXT11_API_KEY": "ctx11_your_api_key_here"
}
}
}
}Tools
search_context
Search the company knowledge base for relevant context, guidelines, and rules.
Parameters:
Name | Type | Description |
| string | What to search for in the knowledge base |
| number | Maximum number of results (default: 10) |
Example:
{
"query": "brand guidelines",
"limit": 5
}get_document
Get the full content of a specific document by ID.
Parameters:
Name | Type | Description |
| string | Document ID from search results |
Example:
{
"id": "abc123"
}list_folders
List all folders in the workspace.
Parameters: None
Example Response:
Found 2 folder(s):
- **Engineering** (ID: abc123)
Documents: 5, Subfolders: 2
- **Marketing** (ID: def456)
Documents: 3, Subfolders: 0list_documents
List all documents in a specific folder.
Parameters:
Name | Type | Description |
| string | The folder ID to list documents from |
Example:
{
"folderId": "abc123"
}read_document
Read a document's full content by ID.
Parameters:
Name | Type | Description |
| string | The document ID to read |
Example:
{
"documentId": "abc123"
}update_document
Update a document's title and/or content. Content must be in Tiptap JSON format.
Parameters:
Name | Type | Description |
| string | The document ID to update |
| string | (Optional) New title for the document |
| string | (Optional) New content in Tiptap JSON format |
Example:
{
"documentId": "abc123",
"title": "Updated Title",
"content": "{\"type\":\"doc\",\"content\":[{\"type\":\"paragraph\",\"content\":[{\"type\":\"text\",\"text\":\"Hello world\"}]}]}"
}Development
# Install dependencies
npm install
# Build
npm run build
# Watch mode
npm run devLicense
MIT
Available Tools
6 toolsget_documentB
Get the full content of a specific document by ID
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Document ID from search results |
TDQS
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 only states that it gets full content, but does not mention potential side effects, required permissions, error behavior, or return format, which is a significant gap for a read operation without annotation support.
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, concise sentence: 'Get the full content of a specific document by ID'. It is front-loaded with the action and resource, contains no unnecessary words, and is easy to parse.
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 simple one-parameter tool, the description provides the essential purpose, but it lacks details on expected output format, error cases, or permissions. The absence of an output schema and annotations increases the need for such context, making the description minimally complete.
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 input schema has 100% description coverage, with the 'id' parameter described as 'Document ID from search results'. The description itself adds little beyond saying 'by ID', but the schema already provides sufficient meaning, so a baseline of 3 applies.
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 retrieves the full content of a document by its ID, with a specific verb and resource. However, it does not distinguish itself from the sibling tool 'read_document', which likely serves a similar purpose, so it lacks 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 gives no guidance on when to use this tool instead of alternatives such as read_document or search_context. It neither provides context for appropriate usage nor exclusions, leaving the agent to infer when to choose this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_documentsA
List all documents in a specific folder
| Name | Required | Description | Default |
|---|---|---|---|
| folderId | Yes | The folder ID to list documents from |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It states a read operation ('list') but does not explain return format, pagination, whether subfolders are included, or any auth requirements. The description adds no context beyond the base action.
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?
A single sentence, front-loaded with the action and object, with zero waste. Perfectly 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?
For a simple one-parameter read tool with no annotations and no output schema, the description is minimally adequate but lacks information about return values or edge cases. It is complete enough for the basic use case but leaves important behavioral questions unanswered.
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 coverage is 100% with a clear description of folderId. The description adds no additional meaning beyond the schema, so the baseline 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 'List all documents in a specific folder' uses a specific verb ('List') and resource ('documents in a folder'), clearly distinguishing it from siblings like get_document or read_document (single doc) and list_folders (folders). It precisely states the scope.
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 implies usage (when you need to list all docs in a folder), but does not explicitly state when to use this over search_context or read_document, nor any exclusions or alternatives. Context is only inferred from sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_foldersA
List all folders in the workspace
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states 'List all folders' without mentioning whether this includes nested folders, any ordering, or what the return format looks like. It does not contradict any annotation, but it lacks basic behavioral context such as read-only nature or potential side effects.
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, front-loaded sentence: 'List all folders in the workspace'. Every word earns its place, with no filler or redundancy. It is optimally 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?
For a simple tool with no parameters and no output schema, the description clearly states the action and scope. It is minimally complete, though a brief note on the return structure (e.g., an array of folder names) would make it fully self-explanatory. The lack of such detail prevents a perfect score.
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 tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and it adds no conflicting information. It is sufficient given there is nothing to document.
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 uses the specific verb 'List' with the resource 'folders' and scopes it to 'the workspace', clearly distinguishing this tool from document-related siblings like list_documents and get_document. There is no ambiguity about what the tool does.
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 tool's purpose is clear from the description, so when to use it is implied (when you need to enumerate folders). However, it provides no explicit guidance on when not to use it or alternatives, such as mentioning that other tools handle documents or context. The absence of exclusions makes it adequate but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
read_documentB
Read a document's full content by ID
| Name | Required | Description | Default |
|---|---|---|---|
| documentId | Yes | The document ID to read |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only mentions reading full content, but does not describe return format, error behavior, permissions, or how it differs from get_document. This is minimal for a read 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, concise sentence with no unnecessary words. It front-loads the verb and clearly communicates the core functionality.
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 tool with one parameter and no output schema, the description tells the basic action and lookup method. However, it leaves gaps: what constitutes 'full content' (plain text, formatted, paginated) and behavior for invalid or missing IDs are unspecified. Adequate for a trivial tool but not fully complete.
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 input schema already describes documentId with 100% coverage. The description's 'by ID' aligns with the schema but adds no additional meaning such as format, examples, or constraints beyond what the schema provides.
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 action (read), resource (document), and scope (full content), with a clear lookup method (by ID). However, it does not explicitly differentiate itself from sibling tool get_document, which may also read document content.
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 usage guidance is provided regarding when to use this tool versus alternatives like get_document or list_documents. The description only states the tool's function without any context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_contextB
Search the company knowledge base for relevant context, guidelines, and rules
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results to return (default: 10) | |
| query | Yes | What to search for in the knowledge base |
TDQS
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 only states the action 'search' without detailing return format, pagination, read-only nature, or any constraints. This is a significant gap for a tool that could be used for context retrieval.
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 that starts with the action verb 'Search'. It contains no redundant words or information, making it highly concise and well-suited for quick comprehension.
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?
The tool is simple with two parameters, and the schema fully documents them. However, without an output schema or annotations, the description could have been more complete by describing the nature of results (e.g., list of document IDs, snippets) or any additional context to set expectations. It provides a minimum viable description but lacks depth.
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 coverage is 100%, with both 'query' and 'limit' having descriptive comments. The description adds minimal semantic value beyond the schema, only hinting at the content type ('context, guidelines, and rules'). This aligns with the baseline 3 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 'search[es] the company knowledge base for relevant context, guidelines, and rules', using a specific verb and resource. It distinguishes itself from sibling tools like get_document and list_documents by focusing on searching rather than retrieving or listing specific documents, though it doesn't explicitly contrast itself with them.
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 where search_context is preferred over sibling tools or any exclusion criteria. The sibling names imply broader document operations, but the description itself offers no usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
update_documentA
Update a document's title and/or content. Content must be in Tiptap JSON format.
| Name | Required | Description | Default |
|---|---|---|---|
| title | No | New title for the document | |
| content | No | New content in Tiptap JSON format. Example: {"type":"doc","content":[{"type":"paragraph","content":[{"type":"text","text":"Your text here"}]}]} | |
| documentId | Yes | The document ID to update |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden. It discloses the Tiptap JSON requirement, but this is redundant with the schema's parameter description. It fails to mention side effects, permissions, error behavior, or whether content is replaced or merged. No added behavioral context beyond the schema.
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 two short sentences: 'Update a document's title and/or content. Content must be in Tiptap JSON format.' It is front-loaded with the action, no redundant words, and all information is relevant.
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 simplicity and full schema coverage, the description covers the core action and the format constraint. However, it lacks guidance on error conditions (e.g., non-existent document), permissions, and response shape. No output schema exists, so the description should have addressed these, making it slightly incomplete.
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 coverage is 100% and each parameter (documentId, title, content) is already well-described in the schema. The description adds minimal value by indicating 'title and/or content,' but this is also inferable from optional parameters. Baseline 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 clearly states the tool's purpose: 'Update a document's title and/or content.' It uses a specific verb (update), resource (document), and specifies the fields affected. It distinguishes itself from sibling read/search tools by focusing on modification.
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 conveys clear usage context: use this tool when you need to change a document's title or content. It doesn't explicitly mention alternatives or exclusions, but the verb and siblings make it evident this is for updates, not reads. The 'and/or' clarifies that at least one field can be provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v1.2.1- First observed
get_document - First observed
list_documents - First observed
list_folders - First observed
read_document - First observed
search_context - First observed
update_document
TDQS
Scored across 6 tools
The tools get_document and read_document are nearly identical—both retrieve full document content by ID—causing clear ambiguity. Other tools are distinct, but this overlap creates confusion over which to use.
Tool names follow a consistent verb_noun pattern (search_, get_, list_, read_, update_). However, the use of both 'get' and 'read' for the same operation is a minor inconsistency that disrupts the pattern.
With 6 tools, the server is well-scoped for a document/knowledge base management purpose. Each tool, apart from the get/read duplication, occupies a clear functional role, and the count is neither sparse nor bloated.
The surface covers search, listing, reading, and updating documents, but lacks create and delete operations. This is a significant gap for a document management server, as users cannot add or remove documents through the tools.
Maintenance
Related MCP Connectors
Securely search and manage workspace context files for AI agents and teams.
Intelligent context infrastructure for AI teams: knowledge graph, sessions, tasks, documents.
Shared, permission-aware company context for AI agents, with provenance, approvals and audit.
Connect your team's living knowledge base — docs, data, issues, CRM — to Claude and ChatGPT.
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides tools for retrieving and processing documentation through vector search, enabling AI assistants to augment their responses with relevant documentation context.76 npm1MIT
- AlicenseAqualityDmaintenanceEnables seamless integration with Convolut Context Bank for AI-powered context management, search, consolidation, and export operations. Provides 11 powerful tools for creating, managing, and analyzing contexts with semantic search and automated planning capabilities.115 npmMIT
- AlicenseNot gradedqualityDmaintenanceEnables to search and retrieve chunks from a fictional library's documentation through three tools (kb_search, kb_fetch, kb_sources), allowing LLMs to perform RAG queries via the Model Context Protocol.MIT
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to access Contractor Scale internal context, including client background, meeting transcripts, and team summaries, via three tools: list_clients, get_client_context, and get_meetings.-