Docs Navigator MCP - SUSE Edition
Docs Navigator MCP - SUSE Edition

An AI-powered documentation navigator built as a Model Context Protocol (MCP) server that enables intelligent search, summarization, and exploration of SUSE, Rancher, K3s, RKE2, Longhorn, Harvester, NeuVector, and Kubewarden documentation using open-source AI models.
β¨ New: Production-ready with SQLite caching, advanced analytics, concurrent indexing support, and organized codebase!
π¨ View Live Demo - Check out the UI demo on GitHub Pages!
π Documentation
Architecture Overview - System design and components
Installation Guide - Detailed setup instructions
Documentation Sources - All available sources and usage guide
Indexing Guide - Understanding caching vs indexing β
Quick Reference - Command reference
Usage Examples - Common usage patterns
Web GUI Guide - Web interface documentation
MCP Client Setup - Configure MCP clients
SQLite Migration Guide - SQLite caching details
Change Detection - Auto-update system for monitoring doc changes β
GitHub Pages Deployment - Deploy UI showcase to GitHub Pages
Contributing - Contribution guidelines
Related MCP server: MCPDocSearch
π Features
Core Capabilities
π Web GUI - Beautiful localhost web interface for easy access
π Semantic Documentation Search - Find relevant docs using natural language queries
π€ Local Open-Source AI - Powered by Ollama (Llama, Mistral, etc.) - no API keys required
π Multi-Source Support - Navigate SUSE, Rancher, K3s, RKE2, Longhorn, Harvester, NeuVector, Kubewarden documentation
π¬ Conversational Interface - Ask questions and get answers with source citations
π Smart Summarization - Generate concise or detailed summaries of documentation
π MCP Protocol - Integrates with Claude Desktop and other MCP-compatible clients
β‘ Vector Search - Fast semantic retrieval using embeddings
π― Flexible AI Providers - Support for Ollama (local), OpenAI, or Anthropic
Production Features (NEW!)
πΎ SQLite Caching - Efficient page caching with SQLite for scaling to 1000s of documents
π Analytics Reports - Comprehensive cache analytics and health monitoring
π Advanced Queries - Filter cached documents by source, status, date range
π Concurrent Indexing - Safe multi-process indexing with automatic locking
π Cache Management - Validate, clear, rebuild, and optimize caches
π― Smart Indexing - Conditional GET requests, ETag/Last-Modified support, content hash detection
π Change Detection - Monitor docs for updates and auto-trigger re-indexing
π¦ Organized Codebase - Clean directory structure with CLI/services/tests/utils separation
ποΈ Architecture
graph TB
subgraph "Client Layer"
WEB[π Web Browser<br/>localhost:3000]
CLAUDE[π€ Claude Desktop<br/>MCP Client]
CLI[β¨οΈ CLI Tools<br/>npm commands]
end
subgraph "Application Layer"
WEBSERVER[π₯οΈ Web Server<br/>Express.js<br/>Port 3000]
MCP[π‘ MCP Server<br/>index.js<br/>stdio protocol]
CLITOOLS[π οΈ CLI Tools<br/>indexer, analytics,<br/>cache manager]
end
subgraph "Service Layer"
DOCSERVICE[π Documentation Service<br/>- Fetch & Parse HTML<br/>- Content Extraction<br/>- Sitemap Processing]
AISERVICE[π§ AI Service<br/>- LLM Integration<br/>- Prompt Management<br/>- Response Formatting]
VECTORSERVICE[π Vector Service<br/>- Embedding Generation<br/>- Semantic Search<br/>- Similarity Ranking]
CACHESERVICE[πΎ Cache Service<br/>- SQLite Operations<br/>- Page Management<br/>- Lock Handling]
end
subgraph "Storage Layer"
SQLITE[(ποΈ SQLite Database<br/>page-cache.db<br/>- Pages Table<br/>- Locks Table)]
VECTORS[(π Vector Index<br/>vectra/index.json<br/>- Embeddings<br/>- Metadata)]
HTMLCACHE[π HTML Cache<br/>data/html/<br/>cached pages]
end
subgraph "External Services"
OLLAMA[π¦ Ollama<br/>Local LLMs<br/>localhost:11434]
OPENAI[π OpenAI API<br/>GPT Models<br/>Embeddings]
ANTHROPIC[π· Anthropic API<br/>Claude Models]
DOCS[π Documentation Sites<br/>- docs.k3s.io<br/>- ranchermanager.docs<br/>- documentation.suse.com<br/>- etc.]
end
%% Client connections
WEB -->|HTTP/REST API| WEBSERVER
CLAUDE -->|stdio/MCP| MCP
CLI -->|Node.js| CLITOOLS
%% Application layer connections
WEBSERVER -->|Use Services| DOCSERVICE
WEBSERVER -->|Use Services| AISERVICE
WEBSERVER -->|Use Services| VECTORSERVICE
MCP -->|Use Services| DOCSERVICE
MCP -->|Use Services| AISERVICE
MCP -->|Use Services| VECTORSERVICE
CLITOOLS -->|Use Services| DOCSERVICE
CLITOOLS -->|Use Services| CACHESERVICE
%% Service layer connections
DOCSERVICE -->|Read/Write| CACHESERVICE
DOCSERVICE -->|Fetch| DOCS
DOCSERVICE -->|Store HTML| HTMLCACHE
AISERVICE -->|Query LLM| OLLAMA
AISERVICE -->|Query LLM| OPENAI
AISERVICE -->|Query LLM| ANTHROPIC
VECTORSERVICE -->|Generate Embeddings| OLLAMA
VECTORSERVICE -->|Generate Embeddings| OPENAI
VECTORSERVICE -->|Read/Write| VECTORS
CACHESERVICE -->|SQL Operations| SQLITE
%% Styling
classDef clientStyle fill:#e1f5ff,stroke:#01579b,stroke-width:2px
classDef appStyle fill:#f3e5f5,stroke:#4a148c,stroke-width:2px
classDef serviceStyle fill:#e8f5e9,stroke:#1b5e20,stroke-width:2px
classDef storageStyle fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef externalStyle fill:#fce4ec,stroke:#880e4f,stroke-width:2px
class WEB,CLAUDE,CLI clientStyle
class WEBSERVER,MCP,CLITOOLS appStyle
class DOCSERVICE,AISERVICE,VECTORSERVICE,CACHESERVICE serviceStyle
class SQLITE,VECTORS,HTMLCACHE storageStyle
class OLLAMA,OPENAI,ANTHROPIC,DOCS externalStyleKey Components
Web GUI: Modern React-like interface for interactive documentation search
MCP Server: Model Context Protocol implementation for Claude Desktop integration
CLI Tools: Command-line utilities for indexing, analytics, and cache management
Documentation Service: Handles fetching, parsing, and caching of documentation pages
AI Service: Manages LLM interactions with support for multiple providers (Ollama, OpenAI, Anthropic)
Vector Service: Generates embeddings and performs semantic search using Vectra
Cache Service: SQLite-based caching system with locking for concurrent operations
π Recent Updates (December 2025)
Phase 3: Production-Ready SQLite Migration
What's New:
SQLite Caching System
Migrated from JSON to SQLite for better scalability
Support for 1000s of documents without performance degradation
Automatic schema creation with indexes on source, status, timestamps
Backward compatible - can revert to JSON with
USE_JSON_CACHE=true
Advanced Analytics & Queries
npm run analytics- Comprehensive cache health reportsnpm run query-cache- Filter by source, status, date rangeCache efficiency metrics, stale page detection, automated recommendations
By-source breakdowns showing indexed/total ratios
Concurrent Indexing Safety
Table-based locking prevents race conditions
30-minute lock timeout with automatic expiration
npm run clear-locksfor manual lock cleanupSafe to run multiple indexing processes simultaneously
Organized Codebase
Clean directory structure:
cli/,services/,tests/,utils/15 files reorganized from root into logical folders
Better maintainability and developer experience
Comprehensive documentation in
src/README.md
Performance Optimizations
Smart caching with ETag/Last-Modified support
Content hash detection skips unchanged documents
Sitemap optimization pre-filters URLs before fetching
Conditional GET requests reduce unnecessary downloads
Migration:
Existing users: Run
npm run migrate-sqliteto convert JSON cacheNew users: SQLite is default, no action needed
See docs/SQLITE_MIGRATION.md for details
π Quick Start
Prerequisites
Node.js 18+ - Download here
Ollama (for local AI) - Download here
OpenAI API Key (optional) - For production embeddings
Step 1: Install Dependencies
# Clone the repository
git clone https://github.com/mso-docs/Docs-Navigator-MCP-SUSE-Edition.git
cd Docs-Navigator-MCP-SUSE-Edition
# Install Node.js dependencies
npm installStep 2: Install AI Models
Option A: Local AI with Ollama (Free, Recommended for Q&A)
# Install Ollama from https://ollama.ai
# Pull required models
ollama pull llama3.2:latest # For answering questions
ollama pull nomic-embed-text # For embeddings (alternative)
# Verify Ollama is running
ollama listOption B: OpenAI (Recommended for Embeddings)
# Get API key from https://platform.openai.com/api-keys
# Add to .env file: OPENAI_API_KEY=your_key_hereHybrid Approach (Best Performance):
Use OpenAI for embeddings (fast, reliable)
Use Ollama for Q&A (free, private)
Step 3: Configure Environment
# Copy example environment file
cp .env.example .env
# Edit .env with your settings
nano .env # or use your favorite editorEssential Configuration:
# For Ollama-only setup
AI_PROVIDER=ollama
EMBEDDING_PROVIDER=ollama
OLLAMA_MODEL=llama3.2:latest
EMBEDDING_MODEL=nomic-embed-text
# For OpenAI embeddings + Ollama Q&A (Recommended)
AI_PROVIDER=ollama
EMBEDDING_PROVIDER=openai
OPENAI_API_KEY=sk-your-key-here
OLLAMA_MODEL=llama3.2:latest
# Cache settings (SQLite is default)
PAGE_CACHE_PATH=./data/page-cache.db
EMBEDDING_CACHE_PATH=./data/embedding-cache.jsonStep 4: Index Documentation
# Index all documentation sources (SUSE, Rancher, K3s)
npm run index all
# Or index individual sources
npm run index k3s
npm run index rancher
npm run index suseFirst-time indexing takes 5-15 minutes depending on your internet speed and AI provider. Subsequent runs are much faster due to caching.
Step 5: Start Using!
Web Interface (Easiest):
npm run webThen open http://localhost:3000 in your browser.
MCP Server (for Claude Desktop):
npm startSee docs/MCP_CLIENT_CONFIG.md for Claude Desktop setup.
π You're Ready!
Try asking questions like:
"How do I install K3s on SUSE?"
"What are the differences between K3s and RKE2?"
"Show me Rancher backup procedures"
See docs/EXAMPLES.md for more usage examples.
π οΈ Available Tools
The MCP server provides these tools:
search_docs
Search documentation using semantic search.
{
"query": "How do I install K3s on SUSE?",
"source": "all",
"limit": 5
}ask_question
Ask questions about documentation and get AI-generated answers with sources.
{
"question": "What are the differences between K3s and RKE2?",
"context": "deployment on SUSE Linux Enterprise"
}summarize_doc
Generate AI summaries of documentation pages.
{
"url": "https://docs.k3s.io/installation",
"format": "bullet-points"
}get_doc_section
Retrieve specific documentation content.
{
"url": "https://documentation.suse.com/sles/15-SP5/"
}index_documentation
Index documentation for faster searching.
{
"source": "k3s",
"forceRefresh": false
}list_doc_sources
View all available documentation sources and their status.
π Usage Examples
Web Interface (Easiest!)
Start the web interface and access it from your browser:
npm run webThen open http://localhost:3000 in your browser. See docs/WEB_GUI.md for details.
With Claude Desktop
Configure Claude Desktop (see docs/INSTALL.md)
Ask Claude to use the tools:
"Can you search the SUSE documentation for information about container security?"
"Use the docs navigator to find K3s installation instructions"
"Summarize the Rancher high availability setup documentation"Direct MCP Usage
# Start the MCP server
npm start
# The server communicates via stdio using MCP protocolCommand-Line Tools
# Indexing
npm run index [source] # Index documentation (k3s, rancher, suse, all)
npm run index all # Index all sources
npm run index k3s --force # Force refresh (ignore cache)
# Cache Management
npm run stats # Show cache statistics
npm run analytics # Comprehensive analytics report
npm run query-cache [opts] # Query cache with filters
npm run clear-cache # Clear all caches
npm run validate # Validate cache integrity
npm run clear-locks # Clear expired indexing locks
# Utilities
npm run fix-sources # Fix legacy cache entries
npm run mark-indexed # Mark documents as indexed
npm run migrate-sqlite # Migrate JSON cache to SQLite
# Testing
npm test # Run test suiteποΈ Architecture
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β User Interfaces β
βββββββββββββββββββ¬ββββββββββββββββββ¬βββββββββββββββββββββββββββ€
β Web Browser β Claude Desktop β Direct MCP Client β
β (port 3000) β (MCP stdio) β (stdio/JSON) β
ββββββββββ¬βββββββββ΄βββββββββ¬βββββββββ΄βββββββββ¬ββββββββββββββββββ
β β β
βΌ βΌ βΌ
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Application Layer (Node.js) β
βββββββββββββββββββ¬ββββββββββββββββββββββββ¬ββββββββββββββββββββ€
β web-server.js β index.js (MCP) β CLI Tools β
β (Express) β (stdio protocol) β (index-docs.js) β
ββββββββββ¬βββββββββ΄ββββββββββββ¬ββββββββββββ΄βββββββββ¬βββββββββββ
β β β
ββββββββββββββββββββββΌβββββββββββββββββββββ
βΌ
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Service Layer β
ββββββββββββββββββββ¬βββββββββββββββββββ¬βββββββββββββββββββββββ€
β AI Service β Vector Service β Doc Service β
β - Ollama Q&A β - Vectra DB β - HTTP fetching β
β - OpenAI embed β - Embeddings β - HTML parsing β
β - Summarization β - Similarity β - Cache management β
ββββββββββ¬ββββββββββ΄βββββββββ¬ββββββββββ΄βββββββββββ¬ββββββββββββ
β β β
βΌ βΌ βΌ
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Data Layer β
βββββββββββββββββ¬ββββββββββββββββββ¬βββββββββββββββββββββββββββββ€
β SQLite Cache β Vectra Vectors β Embedding Cache (JSON) β
β - Page cache β - Doc chunks β - Text hash β vector β
β - Metadata β - Embeddings β - Fast deduplication β
βββββββββββββββββ΄ββββββββββββββββββ΄βββββββββββββββββββββββββββββKey Components
MCP Server (
index.js): Implements Model Context Protocol for tool execution via stdioWeb Server (
web-server.js): Express server providing browser-based UIAI Service: Handles LLM interactions for Q&A and summarization (Ollama/OpenAI/Anthropic)
Cache Service: SQLite-based page caching with advanced queries and analytics
Vector Service: Manages semantic search using Vectra vector database
Documentation Service: Fetches, parses, and indexes documentation with smart caching
Data Flow
Indexing: Docs β Fetch β Parse β Chunk β Embed β Store in Vectra + Cache
Searching: Query β Embed β Vector Search β Retrieve Docs β Return Results
Q&A: Question β Context Search β LLM β Answer with Citations
π§ Configuration
Edit .env to configure:
# AI Provider (ollama, openai, anthropic)
AI_PROVIDER=ollama
# Ollama Settings
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=llama3.2:latest
EMBEDDING_MODEL=nomic-embed-text
# Documentation Sources
SUSE_DOCS_BASE_URL=https://documentation.suse.com
RANCHER_DOCS_URL=https://ranchermanager.docs.rancher.com
K3S_DOCS_URL=https://docs.k3s.io
# Vector Database
VECTOR_DB_PATH=./data/vectorsπ Project Structure
Docs-Navigator-MCP-SUSE-Edition/
βββ docs/ # Documentation files
β βββ ARCHITECTURE.md # System design and components
β βββ INSTALL.md # Detailed installation guide
β βββ QUICKREF.md # Command quick reference
β βββ EXAMPLES.md # Usage examples
β βββ WEB_GUI.md # Web interface guide
β βββ MCP_CLIENT_CONFIG.md # MCP client configuration
β βββ SQLITE_MIGRATION.md # SQLite caching guide
β βββ CONTRIBUTING.md # Contribution guidelines
β
βββ scripts/ # Setup and utility scripts
β βββ setup.sh # Linux/macOS setup script
β βββ setup.bat # Windows setup script
β
βββ src/ # Source code (organized by purpose)
β βββ cli/ # Command-line tools
β β βββ index-docs.js # Main indexing CLI
β β βββ cache-analytics.js # Analytics reports
β β βββ query-cache.js # Cache queries
β β βββ clear-locks.js # Lock management
β β
β βββ services/ # Core business logic
β β βββ ai-service.js # AI/LLM integration
β β βββ cache-service.js # SQLite cache management
β β βββ documentation-service.js # Doc fetching & parsing
β β βββ vector-service.js # Vector database ops
β β
β βββ tests/ # Test scripts
β β βββ test.js # Main test suite
β β βββ test-cache.js # Cache tests
β β βββ test-concurrent-locks.js # Lock tests
β β βββ test-ollama.js # Ollama integration tests
β β
β βββ utils/ # Maintenance utilities
β β βββ migrate-to-sqlite.js # JSONβSQLite migration
β β βββ fix-cache-sources.js # Cache repair tools
β β βββ mark-indexed.js # Status updates
β β
β βββ index.js # MCP server entry point
β βββ web-server.js # Web UI server
β
βββ public/ # Web GUI assets (HTML, CSS, JS)
βββ data/ # Data storage
β βββ vectors/ # Vector database (Vectra)
β βββ page-cache.db # SQLite page cache
β βββ embedding-cache.json # Embedding cache
β βββ html/ # Cached HTML files
β
βββ .env # Environment configurationπ§ Troubleshooting
Installation Issues
Problem: npm install fails
# Clear npm cache and retry
npm cache clean --force
rm -rf node_modules package-lock.json
npm installProblem: Node.js version too old
# Check version (needs 18+)
node --version
# Update Node.js from https://nodejs.org/
# Or use nvm:
nvm install 18
nvm use 18Ollama Issues
Problem: "Connection refused" or "ECONNREFUSED"
# Check if Ollama is running
curl http://localhost:11434/api/tags
# Start Ollama
ollama serve
# Or check Ollama is installed
ollama --versionProblem: Models not found
# List installed models
ollama list
# Pull required models
ollama pull llama3.2:latest
ollama pull nomic-embed-text
# Verify models work
ollama run llama3.2:latest "Hello"Problem: Ollama too slow
# Use OpenAI for embeddings instead
# Edit .env:
EMBEDDING_PROVIDER=openai
OPENAI_API_KEY=your_key_here
# Keep Ollama for Q&A (free and private)
AI_PROVIDER=ollamaIndexing Issues
Problem: Indexing fails with "Item already exists"
# This happens with parallel indexing - use sequential mode
# In .env file:
FETCH_BATCH_SIZE=1
# Or clear vectors and reindex
npm run clear-cache
npm run index allProblem: "Another indexing process is already running"
# Clear stale locks
npm run clear-locks
# Then retry indexing
npm run index allProblem: Indexing very slow
# Use OpenAI embeddings (much faster than Ollama)
# Edit .env:
EMBEDDING_PROVIDER=openai
OPENAI_API_KEY=your_key_here
# Ollama embeddings take ~30 min for 110 docs
# OpenAI embeddings take ~2 min for same docsProblem: "404 Not Found" during indexing
# Some documentation URLs may have changed
# Check cache analytics for details
npm run analytics
# Rebuild specific source
npm run rebuild suseCache Issues
Problem: UI shows "0 documents indexed"
# Check actual cache status
npm run stats
# If cache exists but UI shows 0, restart web server
npm run web
# If genuinely empty, index documentation
npm run index allProblem: Outdated cached content
# Force refresh all caches
npm run index all --force
# Or clear and reindex
npm run clear-cache
npm run index allProblem: Cache corruption
# Validate cache integrity
npm run validate
# If errors found, rebuild
npm run clear-cache
npm run migrate-sqlite # If migrating from JSON
npm run index allWeb Interface Issues
Problem: Web server won't start
# Check if port 3000 is in use
lsof -i :3000 # Linux/Mac
netstat -ano | findstr :3000 # Windows
# Kill process using port 3000 or change port
# Edit src/web-server.js: const PORT = 3001;Problem: "No results found" in web UI
# Verify documents are indexed
npm run stats
# Check AI service is working
npm test
# Verify Ollama/OpenAI connection
curl http://localhost:11434/api/tags # OllamaMCP Server Issues
Problem: Claude Desktop can't connect
# Verify MCP server starts
npm start
# Check Claude Desktop config file location:
# macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
# Windows: %APPDATA%\Claude\claude_desktop_config.json
# Validate config syntax (must be valid JSON)
# See docs/MCP_CLIENT_CONFIG.md for examplesProblem: Tools not appearing in Claude
# Restart Claude Desktop completely
# Check server logs for errors
npm start 2>&1 | tee server.logPerformance Issues
Problem: Slow searches
# Check cache stats
npm run analytics
# Ensure documents are indexed
npm run stats
# Try rebuilding vector index
npm run clear-cache vectors
npm run index allProblem: High memory usage
# Reduce batch sizes in .env:
FETCH_BATCH_SIZE=1
EMBEDDING_CONCURRENCY=1
# Or use OpenAI embeddings (more efficient)
EMBEDDING_PROVIDER=openaiDatabase Issues
Problem: SQLite database locked
# Close all processes accessing database
pkill -f "node src"
# Clear locks
npm run clear-locks
# If persists, delete and rebuild
rm data/page-cache.db
npm run index allProblem: Want to revert to JSON cache
# Edit .env file:
USE_JSON_CACHE=true
PAGE_CACHE_PATH=./data/page-cache.json
# Restart services
npm run webGetting Help
Check logs: Look for error messages in terminal output
Run diagnostics:
npm run statsandnpm run analyticsValidate setup:
npm testto run test suiteCheck documentation: See
docs/folder for detailed guidesGitHub Issues: Report bugs at repository issues page
Common Error Messages
Error | Solution |
| Ollama not running - start with |
| Use |
| Run |
| Normal on first run - table created automatically |
| Documentation URL changed - run |
| Create data directories: |
π€ Contributing
Contributions welcome! This project started during Hack Week 25.
See docs/CONTRIBUTING.md for guidelines.
π License
See LICENSE file for details.
π― Use Cases
DevOps Engineers: Quickly find deployment and configuration info
System Administrators: Navigate SUSE Linux documentation efficiently
Kubernetes Users: Get instant answers about K3s and Rancher
Technical Writers: Research and cross-reference documentation
Support Teams: Find solutions faster with semantic search
π Resources
Platform & Tools
Documentation Sources
Built with β€οΈ for Hack Week 25.
Available Tools
6 toolsask_questionA
Ask a question about SUSE documentation. The AI will search relevant docs and provide an answer with sources.
| Name | Required | Description | Default |
|---|---|---|---|
| context | No | Optional: Additional context or specific area to focus on | |
| question | Yes | The question to answer about SUSE/Rancher/K3s documentation |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool searches docs and returns an answer with sources, but does not explicitly state that it is a read-only operation or describe limitations such as what happens if no relevant documentation is found. The behavior is partially transparent but lacks depth.
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 long, front-loaded with the core action, and contains no extraneous information. 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 simple tool with no output schema, the description adequately explains the result (an answer with sources). It is missing an explicit statement about how it handles out-of-scope questions, but overall it is complete enough for straightforward 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?
The input schema already provides complete descriptions for both parameters ('question' and 'context'). The description adds no additional semantic value for parameters, so the 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's purpose: asking a question about SUSE documentation and returning an answer with sources. It distinguishes itself from siblings like search_docs (which likely returns raw search results) and summarize_doc (which summarizes content) by emphasizing AI-synthesized answers.
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 explicit guidance is given on when to use this tool versus alternatives like search_docs or get_doc_section. The description implies it is for question-answering, but there is no mention of exclusions or when another tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_doc_sectionB
Retrieve a specific section of documentation by URL or identifier.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The URL or identifier of the documentation section |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility for behavioral disclosure. It only says 'Retrieve' and provides no details on error handling, return format, permissions, or behavior for invalid URLs/identifiers. This is a minimal disclosure for a retrieval 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 a single, front-loaded sentence that communicates the core action and parameter without waste. It is appropriately sized for the tool's simplicity.
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 has one parameter, no output schema, and no annotations, yet the description still fails to explain expected output or error behavior. Given the sibling context, there is no mention of when to use this tool vs. searching or summarizing, leaving the agent uncertain about edge cases.
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% β the 'url' parameter is described as 'The URL or identifier of the documentation section'. The description adds no additional semantic detail beyond restating that the section is retrieved by URL or identifier, so a 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 uses a specific verb ('Retrieve') and resource ('a specific section of documentation'), clearly distinguishing it from siblings like search_docs or summarize_doc. The phrase 'by URL or identifier' adds scope, so the purpose is unambiguous.
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 versus alternatives. It does not mention that search_docs should be used when the URL/identifier is unknown, nor any other exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
index_documentationA
Index documentation from specified sources for faster searching. This should be run initially or to update the index.
| Name | Required | Description | Default |
|---|---|---|---|
| source | Yes | Documentation source to index | |
| forceRefresh | No | Force re-indexing even if cache exists |
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 for behavioral disclosure. It does not mention side effects, idempotency, or that indexing overwrites existing data, despite being a mutation tool. The presence of a 'forceRefresh' parameter hints at cache behavior, but the description omits any implications.
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, front-loaded with the core action and purpose. Every sentence contributes value, 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?
Given the tool has two parameters, no output schema, and no annotations, the description is minimally viable but leaves gaps. It states the primary use case but does not explain the effect of indexing, the meaning of 'update the index,' or any prerequisites. This is adequate for a simple tool 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 description coverage is 100%, with both parameters documented. The description adds no extra meaning beyond the schema, so it meets the baseline but does not exceed it. The enum values for 'source' are not elaborated in the description, but that's acceptable given full 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 action ('Index documentation from specified sources') and its purpose ('for faster searching'). It distinguishes from sibling tools that are for retrieval/summarization, establishing this as a maintenance operation.
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 timing guidance: 'run initially or to update the index.' This tells the agent when to invoke the tool, though it does not explicitly mention alternatives or when not to use it. Sibling tool names imply the distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_doc_sourcesA
List all available documentation sources and their status.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool returns status, but does not clarify whether the operation is read-only, how status is defined, or what happens if no sources exist. The behavior is mostly predictable for a list tool, but the description provides minimal extra 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, front-loaded sentence with no unnecessary words. It covers the essential action and result in a concise, well-structured manner.
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, zero-parameter list tool, the description is largely complete. It explains the purpose and that status is included, but does not detail the exact return format or the meaning of 'status'. Given the tool's simplicity and the context from sibling names, this is adequate.
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 there is nothing for the description to explain. Per the rubric, a baseline of 4 is appropriate when no parameters exist, since the schema covers everything vacuously.
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 action ('List'), resource ('documentation sources'), and additional detail ('and their status'). It is easily distinguished from sibling tools that get sections, search, summarize, ask, or index documentation.
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?
Usage is implied rather than explicitly stated: it lists available sources, so one would use it to get an overview. However, there is no explicit guidance about when to choose this over alternatives or any exclusions, leaving the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_docsA
Search SUSE, Rancher, K3s, and related documentation using semantic search. Returns relevant documentation sections.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results to return (default: 5) | |
| query | Yes | The search query to find relevant documentation | |
| source | No | Optional: Filter by documentation source (suse, rancher, k3s, all) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the burden of behavioral disclosure. It mentions 'semantic search' and returns 'relevant documentation sections,' which gives some idea of behavior, but it doesn't disclose potential rate limits, authentication needs, whether results are snippets or full text, or whether any other side effects exist. It's minimal but not misleading.
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, no wasted words. The first sentence is front-loaded with the action ('Search'), and the second explains the return type. 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 simple 3-parameter search tool, the description is adequate but leaves gaps. It doesn't clarify the output format (e.g., URLs, titles, snippets) or how the optional source filter works. Given the sibling get_doc_section, it would help to state that search returns results that may be retrieved with get_doc_section. Still, the tool is simple enough that this is acceptable.
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 parameter descriptions for query, limit, and source. The description adds no extra parameter semantics, so baseline 3 applies. It doesn't explain how the source filter interacts with the search or what the limit controls beyond the schema's description.
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 performs a semantic search over specific documentation sets (SUSE, Rancher, K3s) and returns relevant sections. This is a specific verb-resource pair that differentiates it from siblings like get_doc_section (retrieving a section) or summarize_doc (summarizing), even though it doesn't explicitly name 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?
No guidance is given on when to use this tool versus alternatives. It doesn't mention exclusions like 'use get_doc_section for retrieving a known section' or 'use ask_question for natural-language questions.' The context implies it's for discovery, but sibling differentiation is absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
summarize_docA
Generate an AI-powered summary of a documentation page or section using open-source models.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The URL of the documentation to summarize | |
| format | No | Summary format: brief, detailed, or bullet-points |
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 mentions 'AI-powered' and 'open-source models' but does not disclose potential limitations, latency, or what happens if the URL is invalid or inaccessible. No side effects or prerequisites beyond the existence of a URL are stated.
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, well-formed sentence that states the action and scope. It is front-loaded and contains no redundant or filler content.
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 has a simple 2-parameter schema and no output schema, so the description should clarify expected return behavior. It does not explain what the summary output looks like or how it is returned (e.g., plain text, structured object). Given the absence of annotations and output schema, this is a notable gap, but the description covers the core purpose adequately for a simple tool.
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%: both 'url' and 'format' have clear descriptions, including an enum for format. The tool description adds no additional parameter context, but with full schema coverage, the schema adequately documents the parameters.
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 'Generate' and clearly states the resource ('summary of a documentation page or section'), which unambiguously distinguishes it from siblings like get_doc_section or search_docs. It immediately communicates the tool's core function.
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?
Usage context is implied by the description ('summary' vs. retrieval/search), but there is no explicit guidance on when to use this tool over siblings. For example, it does not state that this should be used instead of get_doc_section when a synthesized overview is needed or search_docs when looking for specific information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clear, distinct purpose: direct retrieval, semantic search, summarization, Q&A, index management, and source listing. No two tools overlap in function, and the descriptions clearly differentiate them.
All tool names follow the verb_noun pattern with lowercase and underscores. The verbs (get, search, summarize, ask, index, list) are consistent and the nouns are descriptive. Minor singular/plural variations do not detract from the overall pattern.
The server has 6 tools, which is well within the ideal range. Each tool serves a necessary function for a documentation navigator, with no redundant or superfluous tools.
The tool surface covers the core workflows of a documentation navigator: indexing sources, searching, retrieving specific sections, summarizing, and asking questions. There are no obvious dead ends or missing operations for the stated purpose.
Maintenance
Related MCP Connectors
Versioned documentation registry and semantic search for AI tools and coding assistants.
Provide your AI coding tools with token-efficient access to up-to-date technical documentation forβ¦
Generate, search, and manage codebase documentation on DocuWriter.ai. 72 tools incl. Autopilot.
Governed, auditable knowledge your team curates for its AI assistants, self-hostable
Related MCP Servers
- AlicenseNot gradedqualityFmaintenanceEnables AI assistants to enhance their responses with relevant documentation through a semantic vector search, offering tools for managing and processing documentation efficiently.2263MIT
- AlicenseNot gradedqualityNot gradedmaintenanceCrawls documentation websites and provides semantic search capabilities over the content through vector embeddings, enabling natural language queries of technical documentation.2
- AlicenseAqualityCmaintenanceEnables AI assistants to navigate and query hierarchical documentation structures, supporting markdown files with YAML metadata and OpenAPI 3.x specifications. It features intelligent full-text search, metadata filtering, and a built-in web interface for both human and AI-driven documentation access.6MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to search and query documentation with flexible backend configurations (ChromaDB, Xenova embeddings) and supports multiple chunking strategies via an MCP server.6MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/mso-docs/Docs-Navigator-MCP-SUSE-Edition'
If you have feedback or need assistance with the MCP directory API, please join our Discord server