What is Mcp Arcknowledge

mcp-ARCknowledge is a Model Context Protocol (MCP) server designed to unify and manage multiple webhook endpoints for knowledge bases into a single configuration.

Use cases

Use cases include managing FAQs from different platforms, integrating various data sources for research purposes, and providing a unified interface for querying diverse knowledge bases.

How to use

To use mcp-ARCknowledge, clone the repository, configure your webhook endpoints in the ‘knowledge_document_sources.json’ file, and then query the knowledge base with text questions to retrieve aggregated results from the specified sources.

Key features

Key features include the ability to register multiple document sources, query the knowledge base with specific or general searches, and aggregate results from various endpoints into one response.

Where to use

mcp-ARCknowledge can be used in various fields such as customer support, data aggregation, and any application requiring centralized access to multiple knowledge sources.

MCP ArcKnowledge

How it works?

This is a Model Context Protocol (MCP) server for your custom webhook endpoints (knowledgebase).

With this you can you can easily manage and query your list of knowledge base(webhook endpoints).
You can add new document sources by registering their URLs, and optionally provide a description and API key.

You can also list all the registered document sources and view their details.

When you’re ready to ask/search, you can query the knowledge base with a text question , specifying which sources to search or leaving it blank to search all of them.

The tool will then aggregate the results from the queried sources and provide them to you.

Prerequisites

• Go
• Python 3.6+
• Anthropic Claude Desktop app (or Cursor or Cline)
• UV (Python package manager), install with curl -LsSf https://astral.sh/uv/install.sh | sh

Concept

Imagine being able to bridge 1 unified setup where you can connect all your custom knowledge base endpoints webhook in one configuration, eliminating the need for multiple MCP servers.

Demo

See mcp cursor video

Setup Installation

Installing via Smithery

To install ArcKnowledge for Claude Desktop automatically via Smithery:

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

1.Clone repo

git clone https://github.com/dragonjump/mcp-arcknowledge
cd mcp-arcknowledge

2. Configure endpoints
   Make a copy or changeknowledge_document_sources.json.
   See sample_endpoint folder for references on current knowledge endpoints api schema supported. You may change the code as you wish to fit your need.

3. Connect to the MCP server

   Copy the below json with the appropriate {{PATH}} values:

   {
     "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, save this as claude_desktop_config.json in your Claude Desktop configuration directory at:

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

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

~/.cursor/mcp.json

For cline, save this as cline_mcp_settings.json in your configuration

4. Restart Client: Claude Desktop / Cursor / Cline / Windsurf
   Open and restart your client ide for mcp. eg Claude/Cursor/Cline/etc

Windows Compatibility

If you’re running this project on Windows, be aware that go-sqlite3 requires CGO to be enabled in order to compile and work properly. By default, CGO is disabled on Windows, so you need to explicitly enable it and have a C compiler installed.

Steps to get it working:

1. Install a C compiler
   We recommend using MSYS2 to install a C compiler for Windows. After installing MSYS2, make sure to add the ucrt64\bin folder to your PATH.
   → A step-by-step guide is available here.

Architecture Overview

This application consists of simple main component:

Python MCP Server (main.py): A Python server implementing the Model Context Protocol (MCP), which provides standardized tools client to interact with data and invoke api call.

Data Storage

• All storage is runtime local main python server.

Technical Details

1. Client sends requests to the Python MCP server
2. The MCP server lookup its runtime config knowledge base.
3. Then based on your queries, it calls your knowledge base endpoint api,

Troubleshooting

• If you encounter permission issues when running uv, you may need to add it to your PATH or use the full path to the executable.
• Make sure both the Go application and the Python server are running for the integration to work properly.

Starting the Server

1. Config
   Run the server in development mode:

fastmcp dev main.py

Or install it for use with Claude:

fastmcp install main.py

Available Tools

1. Default Loads knowledge list from knowledge_document_sources.json

Default loads knowledge sources from config

knowledge_document_sources.json
 

You may Load custom knowledge from mcp.json environment config

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

2. List all currently registered knowledge sources

Shows and explains the list of all registered knowledge sources.

eg. Show me my arcknowledge list 
 

3. Add New Knowledge Document Source

Add new arcknowledge endpoint url document sources.
Provide url, description purpose and apikey(if any)

eg. Add new arcknowledge data source. Endpoint is http://something.com/api/123.
Purpose is to handle questions on 123 topic. Api key is 'sk-2123123' 
 

4. Querying Specific Knowledge Doc Source

Query the arcknowledge base built from these sources using query_knowledge_base.

eg. Query for me my  knowledge base for product. Question is : Which is most expensive product? 


eg. Query for me my  arcknowledge base for business. Question is :When is the business established? 

eg. Query for me all my  arcknowledge base  . Question is :When is the business established? Which is most expensive product?

Tool Functions

1. add_new_knowledge_document_source(url: str, description:str = None, apikey:str = None) -> str

   • Registers a new document source URL, optionally with a description and API key.
   • Returns: Confirmation message with the new source ID.

2. list_knowledge_document_sources() -> Dict[str, Dict[str, str]]

   • Lists all registered document sources.
   • Returns: Dictionary mapping source IDs to their details (URL, description, API key).

3. query_knowledge_base(query: str, source_ids: List[str] = [], image: str = '') -> str

   • Queries specified document sources (or all if none specified) with a text query and optional image data.
   • Returns: Aggregated results from the queried sources.

Development

Crucial filesProject Structure

mcp-arcknowledge/
├── main.py          # Main server implementation
├── README.md           # Documentation
├── requirements.txt    # Project dependencies

Cursor AI MCP Configuration

1. Create an mcp.json file in your project root:

{
  "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"
  }
}

2. Configure Cursor AI:

   • Open Cursor AI settings
   • Navigate to the MCP section
   • Add the path to your mcp.json file
   • Restart Cursor AI to apply changes

3. Verify Configuration:

# Check if MCP is properly configured
fastmcp check mcp.json

# List available tools
fastmcp list

Adding New Features

1. Define new models in main.py
2. Add new tools using the @mcp.tool() decorator
3. Update documentation as needed

License

MIT

Contributing

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Create a new Pull Request