Knowledge MCP Server

A high-performance Model Context Protocol (MCP) server that aggregates multiple knowledge sources into a unified interface for AI agents and applications.

🎯 Features

• Multi-Source Knowledge Aggregation — Unified access to 4 powerful knowledge sources
• Production-Ready — Built-in rate limiting, caching, and structured logging
• High Performance — In-memory caching reduces API calls by up to 80%
• API Compliant — Respects rate limits for all external APIs
• Configurable — Environment-based configuration for all features
• Type-Safe — Full TypeScript implementation with strict typing

📚 Knowledge Sources

Source	Description	Rate Limit	Cache TTL
Context7	Up-to-date library & framework documentation	60 req/hour (free tier)	Configurable
Wikipedia	General knowledge & encyclopedic content	70 req/s	15 minutes
arXiv	Academic papers & research publications	1 req/3s	10-15 minutes
DevDocs	Developer documentation for popular libraries	5 req/s	15-30 minutes

⚠️ DevDocs Disclaimer: The DevDocs integration uses an unofficial API and is not affiliated with or endorsed by DevDocs.io. It may break if the site's structure changes. We'll endeavor to update it promptly, but use in production at your own discretion.

📦 Installation

Prerequisites

• Node.js >= 18.0.0
• npm or yarn
• npx (usually comes with Node.js)

Quick Start

# Clone the repository
git clone https://github.com/Maouv/knowledge-mcp-server.git
cd knowledge-mcp-server

# Install dependencies
npm install

# Build the project
npm run build

# Start the server
npm start

The server will start at http://localhost:3000/mcp by default.

⚙️ Configuration

Create a .env file in the project root (or copy from .env.example):

cp .env.example .env

Core Configuration

# Server Configuration
PORT=3000                          # Server port (default: 3000)
TRANSPORT=http                     # Transport mode: 'http' or 'stdio'

# User-Agent (Required by some APIs)
USER_AGENT=knowledge-mcp-server/2.0.0 (your-contact@example.com)

# Logging
LOG_LEVEL=info                     # Levels: error, warn, info, debug

# Rate Limiting
RATE_LIMIT_ENABLED=true            # Enable/disable rate limiting
RATE_LIMIT_WIKIPEDIA=70            # Requests per second
RATE_LIMIT_ARXIV=0.33              # 1 request per 3 seconds
RATE_LIMIT_CONTEXT7=60             # Requests per hour
RATE_LIMIT_DEVDOCS=5               # Requests per second

# Caching
CACHE_ENABLED=true                 # Enable/disable caching
CACHE_TTL=600                      # Default cache TTL in seconds

Environment Variables Reference

Variable	Type	Default	Description
PORT	number	3000	HTTP server port
TRANSPORT	string	http	Transport mode (http or stdio)
USER_AGENT	string	(required)	User agent for API requests
LOG_LEVEL	string	info	Logging verbosity level
RATE_LIMIT_ENABLED	boolean	true	Enable rate limiting
RATE_LIMIT_WIKIPEDIA	number	70	Wikipedia requests per second
RATE_LIMIT_ARXIV	number	0.33	arXiv requests per second
RATE_LIMIT_CONTEXT7	number	60	Context7 requests per hour
RATE_LIMIT_DEVDOCS	number	5	DevDocs requests per second
CACHE_ENABLED	boolean	true	Enable response caching
CACHE_TTL	number	600	Default cache TTL (seconds)

🚀 Usage

HTTP Mode (Recommended)

Start the server:

npm start
# or with custom port
PORT=8080 npm start

Connect to your MCP client:

{
  "mcpServers": {
    "knowledge": {
      "url": "http://localhost:3000/mcp"
    }
  }
}

Stdio Mode

For local development or subprocess usage:

TRANSPORT=stdio npm start

Client configuration:

{
  "mcpServers": {
    "knowledge": {
      "command": "node",
      "args": ["/path/to/knowledge-mcp-server/dist/index.js"],
      "env": { "TRANSPORT": "stdio" }
    }
  }
}

🔧 Available Tools

Wikipedia Tools

wikipedia_summary

Get a summary of a Wikipedia article by title.

Arguments:

• title (string): Article title (e.g., "JavaScript", "Machine learning")

Example:

{
  "title": "React (software)"
}

wikipedia_search

Search Wikipedia articles.

Arguments:

• query (string): Search query
• limit (number, optional): Number of results (1-20, default: 5)

wikipedia_related

Get related articles linked from a Wikipedia article.

Arguments:

• title (string): Article title

---

arXiv Tools

arxiv_search

Search academic papers on arXiv.

Arguments:

• query (string): Search query
• limit (number, optional): Number of results (1-20, default: 5)
• category (string, optional): arXiv category filter (e.g., "cs.AI", "cs.LG")

Example:

{
  "query": "large language models",
  "category": "cs.CL",
  "limit": 10
}

arxiv_get_paper

Get full details of a specific paper.

Arguments:

• paperId (string): arXiv paper ID or URL

---

Context7 Tools

context7_resolve_library

Resolve a library name to its Context7-compatible ID.

Arguments:

• libraryName (string): Library name (e.g., "react", "nextjs")

context7_get_docs

Fetch up-to-date documentation for a library.

Arguments:

• libraryId (string): Context7 library ID (from context7_resolve_library)
• topic (string, optional): Specific topic to focus on
• tokens (number, optional): Max tokens to return (1000-10000, default: 5000)

---

DevDocs Tools

devdocs_list

List all available documentation sets.

devdocs_search

Search within a documentation set.

Arguments:

• slug (string): Documentation slug (e.g., "react", "node")
• query (string): Search term
• limit (number, optional): Max results (1-30, default: 10)

devdocs_get_page

Fetch full page content.

Arguments:

• slug (string): Documentation slug
• path (string): Page path from search results

📊 Example Workflows

Finding React Documentation

# 1. List available docs
devdocs_list()

# 2. Search for hooks
devdocs_search(slug: "react", query: "useState")

# 3. Get the full page
devdocs_get_page(slug: "react", path: "hooks/use-state")

Researching Machine Learning Papers

# 1. Search arXiv
arxiv_search(query: "transformer architectures", category: "cs.LG", limit: 5)

# 2. Get specific paper details
arxiv_get_paper(paperId: "2301.00001")

Learning About a Concept

# 1. Get Wikipedia overview
wikipedia_summary(title: "Artificial neural network")

# 2. Find related concepts
wikipedia_related(title: "Artificial neural network")

# 3. Search for research papers
arxiv_search(query: "neural networks")

🏗️ Architecture

┌─────────────────────────────────────────────┐
│         Knowledge MCP Server                │
├─────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐ │
│  │ Wikipedia│  │  arXiv   │  │ Context7 │ │
│  │  Service │  │ Service  │  │ Service  │ │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘ │
│       │             │              │       │
│  ┌────▼─────────────▼──────────────▼─────┐│
│  │      Rate Limiter (Bottleneck)        ││
│  └────────────────────┬──────────────────┘│
│                       │                    │
│  ┌────────────────────▼──────────────────┐│
│  │       Cache Layer (node-cache)        ││
│  └────────────────────┬──────────────────┘│
│                       │                    │
│  ┌────────────────────▼──────────────────┐│
│  │      Logging (Winston)                ││
│  └───────────────────────────────────────┘│
└─────────────────────────────────────────────┘

🛡️ Rate Limiting

This server implements respectful rate limiting for all external APIs to ensure compliance and reliability:

Wikipedia

• Official Limit: ~200 requests/second
• Server Default: 70 requests/second (safe buffer)
• Reasoning: Conservative approach to avoid throttling

arXiv

• Official Limit: 1 request per 3 seconds
• Server Default: Strict 1 request per 3 seconds
• Reasoning: arXiv has very strict limits; violations may result in IP bans

Context7

• Free Tier Limit: 60 requests/hour
• Server Default: 60 requests/hour
• Paid Plans: Configurable via RATE_LIMIT_CONTEXT7 env var
• Reasoning: Matches Upstash free tier quota

DevDocs

• Official Limit: Not officially documented (unofficial API)
• Server Default: 5 requests/second
• Reasoning: Conservative to avoid service disruption

Behavior

When rate limits are reached:

• Requests are automatically queued
• No errors are thrown
• Logs warn when approaching limits
• Requests execute when capacity is available

To disable rate limiting (not recommended for production):

RATE_LIMIT_ENABLED=false

🗄️ Caching Strategy

The server uses in-memory caching to reduce API calls and improve response times:

Source	Cache TTL	Reasoning
Wikipedia Summaries	15 minutes	Content rarely changes rapidly
arXiv Search	10 minutes	Papers don't change after publication
arXiv Papers	15 minutes	Static content
DevDocs List	1 hour	Documentation index rarely changes
DevDocs Search	15 minutes	Reasonable balance
DevDocs Pages	30 minutes	Documentation rarely updates frequently
Context7	Configurable	Depends on use case

Cache statistics available programmatically:

import { getCacheStats } from './cache.js';

const stats = getCacheStats();
// { keys: 45, hits: 1234, misses: 56 }

To disable caching:

CACHE_ENABLED=false

📝 Logging

Structured logging via Winston with multiple log levels:

# Development (verbose)
LOG_LEVEL=debug npm start

# Production (standard)
LOG_LEVEL=info npm start

# Minimal
LOG_LEVEL=error npm start

All logs are written to stderr (stdout is reserved for MCP protocol).

Example log output:

2024-01-15 10:23:45 [info]: knowledge-mcp-server running on http://localhost:3000/mcp
2024-01-15 10:23:50 [info]: Rate limiting enabled {"wikipedia":"70 req/s","arxiv":"0.33 req/s"}
2024-01-15 10:24:01 [info]: Searching arXiv {"query":"transformers","limit":5}

🔍 Health Check

Check server health:

curl http://localhost:3000/health

Response:

{
  "status": "ok",
  "server": "knowledge-mcp-server",
  "version": "2.0.0",
  "tools": ["wikipedia", "context7", "arxiv", "devdocs"]
}

🧪 Development

Build

npm run build

Development Mode

npm run dev

Project Structure

knowledge-mcp-server/
├── src/
│   ├── index.ts           # Entry point
│   ├── constants.ts       # Configuration constants
│   ├── types.ts           # TypeScript type definitions
│   ├── logger.ts          # Winston logger setup
│   ├── cache.ts           # In-memory caching layer
│   ├── rateLimiter.ts     # Rate limiting logic
│   ├── services/          # External API integrations
│   │   ├── wikipedia.ts
│   │   ├── arxiv.ts
│   │   ├── context7.ts
│   │   └── devdocs.ts
│   └── tools/             # MCP tool definitions
│       ├── wikipedia.ts
│       ├── arxiv.ts
│       ├── context7.ts
│       └── devdocs.ts
├── dist/                  # Compiled JavaScript
├── package.json
├── tsconfig.json
├── .env.example
└── README.md

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Development Setup

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Code Style

• TypeScript with strict mode
• ES Modules (ESM)
• Async/await for asynchronous operations
• Meaningful variable and function names
• Comprehensive error handling

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Model Context Protocol by Anthropic
• Context7 by Upstash
• Wikipedia REST API
• arXiv API
• DevDocs (unofficial API)

📮 Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions

---

Built with ❤️ for the AI community