MCP UnifiedKnowledgeHub

Operational Flow?

arc knowledge diagram

This implements the Model Context Protocol (MCP) layer for your organization's proprietary webhook endpoints (the custom knowledge store).

It grants you the ability to effortlessly govern and probe your collection of knowledge base endpoints (webhooks). You can integrate novel data sources by submitting their access URLs, optionally supplying a descriptive summary and an authentication key.

You are also empowered to enumerate all registered data repositories and examine their specific configurations.

When formulating a search or request, you issue a textual prompt to the knowledge system, designating which sources to interrogate or omitting specification to scan the entire set.

The component subsequently consolidates the retrieved data from the targeted origins and furnishes it to you.

Prerequisites

Go language runtime
Python version 3.6 or later
Anthropic Claude Desktop application (or Cursor/Cline)
UV (Python package manager); install via curl -LsSf https://astral.sh/uv/install.sh | sh

Core Concept

Envision consolidating disparate custom knowledge base webhook feeds into a single, unified configuration framework, circumventing the need for deploying multiple, separate MCP instances.

Demonstration

arcknowledge demo cursor arcknowledge demo cline

View MCP Cursor Video Demonstration

Deployment and Integration

Installation via Smithery

To integrate UnifiedKnowledgeHub into Claude Desktop automatically through Smithery:

bash npx -y @smithery/cli install @dragonjump/mcp-ARCknowledge --client claude

1.Repository Cloning
bash git clone https://github.com/dragonjump/mcp-ARCknowledge cd mcp-ARCknowledge

Endpoint Configuration Duplicate or modify the knowledge_document_sources.json file. Refer to the sample_endpoint directory for the current knowledge endpoint API specification structure. Feel free to customize the source code to match your operational requirements.
Connecting to the MCP Service

Copy the JSON snippet below, ensuring you substitute the correct {{PATH}} placeholders:

{
    "mcpServers": {
        "mcp-arcknowledge": {
            "command": "cmd /c uv",
            "args": [
                "--directory",
                "C:/Users/Acer/OneDrive/GitHub/YourDrive",
                "run",
                "main.py"
            ],
            "env": {
                "DOCUMENT_SOURCES_PATH": "C:/Users/Acer/OneDrive/GitHub/YourDrive/testcustomother.json"
            }
        }
    }
}

For Claude, persist this data as claude_desktop_config.json within your Claude Desktop configuration directory, located at:

~/Library/Application Support/Claude/claude_desktop_config.json

For Cursor, save this configuration as mcp.json in your Cursor settings directory:

~/.cursor/mcp.json

For cline, designate this as cline_mcp_settings.json in your configuration folder.

Client Application Relaunch: Claude Desktop / Cursor / Cline / Windsurf Restart your client IDE application to activate the MCP integration (e.g., Claude/Cursor/Cline/etc).

Windows System Compatibility Notes

If deploying this system on a Windows environment, be advised that the go-sqlite3 dependency necessitates CGO activation for successful compilation and functionality. CGO is deactivated by default on Windows, requiring explicit enabling alongside the installation of a suitable C compiler.

Remedial Actions:

C Compiler Installation
We suggest utilizing MSYS2 for acquiring a C compiler for Windows. Post-MSYS2 installation, ensure the ucrt64\bin path is appended to your system's PATH variable.
→ A comprehensive, sequential guide is accessible here.

System Architecture Summary

This software is structured around one primary module:

Python MCP Service (main.py): A Python-based service adhering to the Model Context Protocol (MCP), which furnishes standardized tooling for the client to interface with data and execute API invocations.

Data Persistence

All persistent state is maintained locally within the running Python service instance.

Technical Specifics

The client initiates communication by sending requests to the Python MCP service.
The MCP service consults its runtime configuration's repository of knowledge.
Subsequently, based on the user's submitted query, it invokes the appropriate knowledge base endpoint API.

Troubleshooting Common Issues

Should permission errors arise during the execution of uv, you might need to integrate uv into your system's PATH or invoke it using its absolute file path.
Verify that both the Go application component and the Python service are active for the integration to operate as intended.

Initiating the Service

Configuration Check Execute the server in a development sandbox mode: bash fastmcp dev main.py

Alternatively, install it for seamless integration with Claude: bash fastmcp install main.py

Available Functionalities

1. Default Loading of Source Metadata

By default, the system loads the registry of knowledge sources from the configuration file:

knowledge_document_sources.json

You retain the option to designate an alternative knowledge repository via the mcp.json environment settings:

    "env": {
        "DOCUMENT_SOURCES_PATH": "C:/Users/Acer/OneDrive/Somewhere/YourDrive/your-custom.json"
    }

2. Cataloging Presently Registered Information Feeds

Displays and elucidates the complete inventory of registered knowledge conduits.

eg. Provide a listing of my unified knowledge repository sources

3. Onboarding a Novel Knowledge Data Conduit

Adds a new endpoint URL to the system's knowledge assets. Required parameters include the URL, an explanatory summary of its purpose, and optionally, an authentication token.

eg. Integrate a new data repository. The access URL is http://something.com/api/123. Its function is to manage queries related to topic 123. The access credential is 'sk-2123123'

4. Directed Inquiry Against a Selected Knowledge Asset

Probes the integrated knowledge repository, constructed from these sources, utilizing the query_knowledge_base mechanism.

eg. Search my unified knowledge base concerning 'product'. The specific question is : What is the most costly item?

eg. Query my informational repository related to 'business operations'. The question is : When was the enterprise formally established?

eg. Search across my entire aggregated knowledge base. The combined queries are : When was the business established? What is the most valuable product?

Tool Functions (API Signatures)

add_new_knowledge_document_source(url: str, description:str = None, apikey:str = None) -> str
- Registers a new document source URL, optionally furnishing a description and API key.
- Output: A confirmation notice detailing the newly assigned source identifier.
list_knowledge_document_sources() -> Dict[str, Dict[str, str]]
- Generates a catalog of every registered document source.
- Output: A dictionary mapping source identifiers to their metadata (URL, description, API key).
query_knowledge_base(query: str, source_ids: List[str] = [], image: str = '') -> str
- Issues a query to designated document repositories (or all, if unspecificed) using a text prompt and optional embedded image data.
- Output: Consolidated findings aggregated from the interrogated sources.

Development Workflow

Essential Project Layout

mcp-arcknowledge/ ├── main.py # Core service implementation logic ├── README.md # Comprehensive user and developer documentation ├── requirements.txt # List of required Python libraries

Configuration for Cursor AI (MCP Manifest)

Establish an mcp.json file in the repository's root directory:

{ "name": "mcp-webhook-ai-agent", "version": "1.0.0", "description": "Webhook AI agent with RAG capabilities", "main": "main.py", "tools": [ { "name": "set_document_source", "description": "Register a new document source URL for RAG operations" }, { "name": "list_document_sources", "description": "List all registered document sources" }, { "name": "query_rag", "description": "Query the specified document sources using RAG" }, { "name": "process_post_query", "description": "Process a POST request with a query payload" } ], "dependencies": { "fastmcp": ">=0.4.0", "requests": ">=2.31.0", "pydantic": ">=2.0.0" } }

Configure the Agent Interface in Cursor AI:
Access Cursor AI preferences/settings menu
Navigate to the MCP integration section
Input the file path pointing to your generated mcp.json file
Restart the Cursor AI environment to apply these modifications
Validation of Setup: bash

Verify successful MCP configuration load

fastmcp check mcp.json

Display all accessible tools

fastmcp list

Incorporating New Features

Define necessary data schemas (models) within main.py.
Introduce new functionalities using the @mcp.tool() decorator for tool exposure.
Ensure documentation is updated to reflect any functional changes.