This server lets Claude query Actian product documentation, analytics, and CI status in plain language, all without credentials using realistic mock data.
search_docs – search the Actian documentation corpus by query, with optional product, version, and result-count filters.
get_topic – retrieve a full documentation topic's Markdown content by ID.
list_topics – browse the corpus index, filtered by product or topic type.
get_content_gaps – surface analytics search queries with zero/low results to identify missing documentation.
get_build_status – check the current Jenkins CI build status for the docs publish pipeline.
Provides tools to check the current Jenkins CI pipeline status for the docs publish job, including build result, stage breakdown, and recent history.
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., "@actian-docs-mcp Search docs for Tableau connector in Analytics Engine"
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.
An MCP (Model Context Protocol) server that exposes Actian product documentation, GA4 content analytics, and Jenkins CI build status to Claude, enabling natural-language queries across all three sources in a single conversation.
Runs with no credentials. The corpus, GA4 analytics, and Jenkins data ship as realistic mock fixtures, so you can clone, build, and query it in about two minutes. Every source has a documented upgrade path to live data. See Live data.
Claude Desktop / Claude Code
│
│ JSON-RPC over stdio
▼
docs-mcp
│
├── search_docs → Actian Markdown corpus (TF-IDF, swap for pgvector)
├── get_topic → Full topic content by ID
├── list_topics → Corpus index with product/type filters
├── get_content_gaps → GA4 zero-result search queries (mock → BigQuery)
└── get_build_status → Jenkins publish pipeline status (mock → live API)Once connected, you can ask Claude:
"What are the top 10 search queries on the Actian docs site that returned no results this month?"
"Find every topic in the Analytics Engine 8.0 corpus that mentions the Tableau connector, and check whether the publish pipeline is currently green."
"Did the docs build pass? If it failed, search the corpus for the RPM upgrade procedure and show me the relevant steps."
Related MCP server: AXYS MCP Lite
git clone https://github.com/Bipin-24/docs-mcp.git
cd docs-mcp
npm install
npm run buildOpen your Claude Desktop config file:
OS | Path |
macOS |
|
Windows |
|
Add this block (replace the path with your actual clone location):
{
"mcpServers": {
"actian-docs": {
"command": "node",
"args": ["/absolute/path/to/docs-mcp/dist/index.js"]
}
}
}Restart Claude Desktop. You should see actian-docs in the tools list.
Drop a .mcp.json file in your project root:
{
"mcpServers": {
"actian-docs": {
"command": "node",
"args": ["../docs-mcp/dist/index.js"]
}
}
}search_docsKeyword search across the documentation corpus, ranked by TF-IDF with title and tag match bonuses. Upgradeable to embedding-based semantic search. See Architecture.
Input:
query string required Natural language search query
product string optional analytics-engine | ingres | actian-client | all
version string optional e.g. "8.0", "11.x"
limit number optional 1–10, default 5
Output: ranked list of matching topics with excerpt and relevance scoreExample prompt: "How do I upgrade Analytics Engine using RPM packages?"
get_topicRetrieve the full Markdown content of a topic by ID.
Input:
topic_id string required Topic ID from search_docs results
Output: full topic content with metadatalist_topicsBrowse the corpus index.
Input:
product string optional analytics-engine | ingres | actian-client | all
topic_type string optional concept | task | reference | troubleshooting | all
Output: topics grouped by productget_content_gapsSurfaces search queries that returned zero or very few results, meaning documentation your users need but that does not exist yet.
Input:
days number optional Lookback window, default 30
limit number optional Max gaps to return, default 20
min_searches number optional Minimum search volume, default 2
Output: ranked gap list with gap type, search volume, and nearest existing topicsExample prompt: "What are the top missing documentation topics based on search data from the last 30 days?"
get_build_statusReturns the current Jenkins CI pipeline status for the docs publish job.
Input:
job string optional Jenkins job name, default "actian-docs-publish"
Output: latest build result, stage breakdown, and recent historyThe server ships with a lightweight TF-IDF keyword search engine (src/lib/search.ts) that requires no external dependencies or API keys. It scores documents using term frequency with title and tag match bonuses.
To upgrade to embedding-based semantic search:
Add chromadb to package.json
Run npm run index to embed the corpus using the Python indexer (scripts/index_corpus.py)
Swap scoreTopics() in src/lib/search.ts for a Chroma similarity query
The server ships with realistic mock data for GA4 analytics and Jenkins. To switch to live sources, add credentials to .env:
cp .env.example .env
# Edit .env with your BigQuery project ID and Jenkins tokenSee .env.example for all available configuration options.
The BigQuery query for GA4 Site Search export is in scripts/ga4_export.sql.
docs-mcp/
├── src/
│ ├── index.ts # MCP server — tool registry and routing
│ ├── tools/
│ │ ├── searchDocs.ts # search_docs handler
│ │ ├── getTopic.ts # get_topic handler
│ │ ├── listTopics.ts # list_topics handler
│ │ ├── getContentGaps.ts # get_content_gaps handler
│ │ └── getBuildStatus.ts # get_build_status handler
│ ├── data/
│ │ ├── corpus.ts # Sample Actian documentation topics
│ │ ├── analyticsData.ts # Mock GA4 site search data
│ │ └── jenkinsData.ts # Mock Jenkins build history
│ └── lib/
│ └── search.ts # TF-IDF search engine
├── scripts/
│ └── ga4_export.sql # BigQuery query for real GA4 export
├── config/
│ ├── claude_desktop_config.json # Claude Desktop setup
│ └── mcp.json # Claude Code project setup
├── .env.example
└── tsconfig.jsonRuntime: Node.js 18+ / TypeScript
MCP SDK: @modelcontextprotocol/sdk
Search: TF-IDF (built-in), upgradeable to pgvector / Chroma
Analytics: Mock GA4 data, upgradeable to BigQuery
CI status: Mock Jenkins data, upgradeable to live Jenkins REST API
knowflow — MCP server with a RAGAS-style retrieval evaluation layer
knowledge-graphs-for-ia — graph builder with a typed edge model over a documentation corpus
Documentation-AI-Assistant — RAG pipeline and chat UI over a documentation corpus
IA Playbook — reference architecture for AI-readable documentation
MIT. See LICENSE.
Bipin Pandey — Principal Information Architect
LinkedIn · Portfolio
Returns the current status of the documentation CI/CD build pipeline in Jenkins, including the last build result, timestamp, and duration.
| Name | Required | Description | Default |
|---|---|---|---|
| job | No | Jenkins job name. Defaults to 'actian-docs-publish'. | actian-docs-publish |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears full responsibility for behavioral disclosure. It does state that the tool 'returns' status information and lists specific return fields, implying a read-only operation. However, it omits details about potential delays, caching, authentication, or error conditions that might be relevant for an agent.
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 that immediately states the purpose and the included output fields. Every word contributes meaning, and there is no redundancy or filler.
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 optional parameter and no output schema, the description adequately conveys what the tool does and what the response contains (last build result, timestamp, duration). It could slightly benefit from mentioning possible build result values or status meanings, but overall it is reasonably 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 fully documents the single optional 'job' parameter with a clear default and description. The tool description adds no extra parameter semantics, so the baseline 3 applies without any need for compensation.
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 'Returns' and clearly identifies the resource as 'the documentation CI/CD build pipeline in Jenkins'. It also lists the key output fields (build result, timestamp, duration), which makes the tool's function unambiguous and distinctly different from the sibling content tools.
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 context (checking build status) but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. Sibling tools are clearly different in domain, so the lack of explicit guidance is not critical, but it is still a gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns search queries from the analytics data that returned zero or low results — i.e. topics that users searched for but documentation does not cover. Use this to identify missing documentation.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Lookback window in days. Defaults to 30. | |
| limit | No | Number of gap entries to return. Defaults to 20. | |
| min_searches | No | Only include queries searched at least this many times. Defaults to 2. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses the core behavior (returns zero/low-result queries) and the interpretative aspect (gaps in documentation). It doesn't mention read-only or data freshness, but for a simple analytics getter, this is adequate.
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?
Two sentences, front-loaded with the core action and followed by a clear use case. Every phrase earns its place; no redundancy or fluff.
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 optional params and no output schema, the description adequately explains the tool's purpose and value. It doesn't describe the return format, but the output (search queries) is inferable from the description and 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 covers all three parameters with descriptions and defaults, so baseline is 3. The tool description adds no extra parameter context, but none is needed; parameters like 'days' and 'min_searches' are self-explanatory in 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 clearly states the tool returns search queries from analytics data with zero or low results, specifically identifying topics users searched but documentation doesn't cover. This specific verb+resource+outcome distinguishes it from siblings like search_docs or list_topics.
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?
Explicitly says 'Use this to identify missing documentation,' giving a clear context. It doesn't name alternatives or exclusions, but the distinct purpose makes when-to-use implicit. It could have been stronger by contrasting with related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve the full Markdown content of a specific documentation topic by its ID. Use search_docs first to find the topic_id, then call this to read the full content.
| Name | Required | Description | Default |
|---|---|---|---|
| topic_id | Yes | Topic ID returned by search_docs |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It clearly states the tool returns Markdown content, which conveys the output format. However, it lacks details about error handling (e.g., invalid topic_id), potential size limits, or any permission requirements, leaving some behavioral ambiguity 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 two sentences, with the primary action stated in the first sentence and supplementary usage guidance in the second. Every word contributes value, with no redundancy or unnecessary detail.
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, the description covers the essential steps: how to obtain the parameter and what the tool returns. It lacks some edge-case details like handling of missing IDs or content formatting nuances, but given the low complexity and clear sibling context, it is nearly 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?
Schema description coverage is 100% as the only parameter topic_id is described as 'Topic ID returned by search_docs.' The description adds the context of searching first but does not provide additional parameter details beyond what the schema already states, so it meets the baseline without exceeding it.
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 states a specific action ('Retrieve the full Markdown content') on a specific resource ('a specific documentation topic by its ID'), making the purpose immediately clear. It also distinguishes itself from sibling tools by explicitly referencing search_docs for finding the topic_id, which prevents confusion.
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 explicit workflow guidance: 'Use search_docs first to find the topic_id, then call this to read the full content.' This tells the agent exactly when to use this tool and how it fits in sequence with search_docs, effectively differentiating it from alternative approaches.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available documentation topics, optionally filtered by product or topic type.
| Name | Required | Description | Default |
|---|---|---|---|
| product | No | all | |
| topic_type | No | all |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral disclosure burden. It states the operation and filtering options, but does not mention result format, ordering, pagination, or any side effects. The basic read-only nature is implied, yet additional behavioral context is absent.
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 that conveys both purpose and filtering parameters without any redundant or vague wording. Every word earns its place.
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 low-complexity list tool with two optional enum parameters and no output schema, the description is almost complete. It clearly states what the tool returns and which filters apply. A minor gap is lacking explicit mention of the default behavior when no filters are provided, though the schema's 'default: all' partially covers this.
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 has no parameter descriptions, so the description must compensate. It does name both parameters as optional filters ('optionally filtered by product or topic type'), adding some meaning beyond the raw property names. However, it does not explain the enum values or the meaning of the 'all' default, leaving part of the semantics to inference.
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 a specific verb ('List') and resource ('documentation topics'), and clearly defines the scope ('all available'). It distinguishes itself from sibling tools like search_docs and get_topic by focusing on listing topics rather than searching or retrieving a single topic.
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 when to use the tool: to enumerate all documentation topics, with optional filtering by product or topic type. It does not explicitly name alternative tools or exclusions, but the context is clear and no misleading guidance is present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Semantic search across Actian documentation. Returns the top matching sections with product, version, and topic-type metadata. Use this to answer questions about Actian products.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of results to return (1–10). Defaults to 5. | |
| query | Yes | Natural language search query | |
| product | No | Filter results by product. Defaults to 'all'. | all |
| version | No | Filter by version string, e.g. '8.0' or '11.x' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavior. It mentions that the search is 'semantic' and that results include product, version, and topic-type metadata, giving the agent a clear expectation of output contents. It does not cover edge cases like empty results or rate limits, but the core behavior is transparently described.
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 exactly two sentences, front-loaded with the main purpose. The first sentence states what the tool does, and the second gives usage guidance and describes the result. There is zero redundancy or filler.
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 has 4 parameters and no output schema, the description provides sufficient context: the purpose, the return contents (top matching sections with metadata), and a practical usage hint ('answer questions'). The schema handles parameter details, so the description fills the necessary gaps without being exhaustive.
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 covers all 4 parameters with descriptions, so parameter semantics are already well-defined. The description adds no additional parameter-specific context, so 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 clearly states the tool's function: 'Semantic search across Actian documentation.' It specifies the resource (Actian documentation), the action (search), and the output (top matching sections with metadata). This distinguishes it from sibling tools like get_topic and list_topics, which are for direct retrieval or listing, not semantic search.
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 explicitly says 'Use this to answer questions about Actian products,' providing a clear use case. However, it does not mention alternatives or exclusions (e.g., when to use get_topic or list_topics instead), so it misses the 'when-not' guidance for a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool targets a distinct operation: semantic search, content retrieval by ID, listing metadata, analytics for gaps, and build pipeline status. There is no overlap or ambiguity between them.
All tool names consistently follow the verb_noun pattern in snake_case (search_docs, get_topic, list_topics, get_content_gaps, get_build_status). The naming is uniform and predictable.
Five tools is a well-scoped set for a documentation server, covering search, retrieval, listing, analytics, and CI/CD status without unnecessary bloat. Each tool earns its place.
The core documentation workflow is covered: discover topics via search/list, retrieve full content, and identify gaps. The build status tool provides complementary operational visibility, making the surface complete for its purpose.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Query your org's data in natural language — read-only MCP access to SQL, NoSQL, files & warehouses.
Ask data questions in natural language. Get SQL, insights, and charts from your databases.
Query BigQuery, Snowflake, Redshift & Azure Synapse with natural language
Connect Claude, Cursor, or ChatGPT to your business data. Ask questions, get answers.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Bipin-24/docs-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
