KnowSync AI

No headings found

Connect AI agents to your KnowSync knowledge base using the Model Context Protocol (MCP). Set up API keys, configure tools, and integrate with Claude, Cursor, and other AI assistants.

15 min readBy KnowSync Team9/18/2025

MCP Integration

KnowSync's Model Context Protocol (MCP) server enables AI agents to access your organization's knowledge base in real-time. Connect Claude, Cursor, VS Code, and other AI tools to search, retrieve, and add content to your knowledge base seamlessly.

What is MCP?

Overview

The Model Context Protocol (MCP) is an open standard developed by Anthropic that allows AI applications to securely access external data sources. KnowSync's MCP server provides 2 unified tools with intelligent caching, AI-powered query optimization, and session management that enable AI agents to interact with your knowledge base through a standardized JSON-RPC 2.0 API.

Key Features

2 Unified Tools:

• Universal Query: Intelligent search and retrieval with automatic intent detection, AI-powered reranking, smart caching, and session-aware context preservation
• Document Management: Comprehensive content management including web crawling, discovery, and document operations with usage tracking

Enterprise Security:

• API key authentication with granular permissions
• Rate limiting and usage tracking
• Team member attribution for all requests
• IP restrictions and access controls

Setting Up MCP API Keys

Creating Your First API Key

1. Access MCP Dashboard: Navigate to your organization dashboard and click the MCP Server card
2. Go to API Keys Tab: Click on the API Keys section
3. Create New Key: Click Create API Key button
4. Configure Key Settings:
   • Name: Descriptive name (e.g., "Claude Desktop", "Development Testing")
     • Permissions: Select which tools the key can access
     • Rate Limit: Set requests per hour (based on your plan)

Available MCP Tools

KnowSync provides 2 powerful unified MCP tools that combine the functionality of our previous 5-tool system:

Universal Tools (All Plans)

knowsync_query:

• Universal search and content retrieval with intelligent caching (60-85% faster responses)
• Automatic intent detection (search vs retrieve) with query expansion and optimization
• Session-aware context preservation for follow-up queries with conversation memory
• Smart parameter tuning based on AI query classification and confidence scoring
• AI-powered result reranking for improved relevance (Pro+ plans)
• Embedding similarity cache for lightning-fast repeat queries

Management Tools (All Plans)

knowsync_manage:

• Comprehensive document management operations with usage tracking
• List and browse documents with advanced filtering and status monitoring (0.5 API units)
• Add specific web pages to your knowledge base with full vector processing (2 API units per URL: 1 crawl + 1 processing)
• Research and discover relevant web content with automatic processing (2 API units per URL discovered)
• Unified interface for all document operations with detailed API consumption tracking

Permission Configuration

Tool-Level Permissions: Each API key can be granted access to specific tools based on your needs:

• Search Only: Ideal for read-only AI agents
• Full Access: Complete access to all available tools
• Custom: Select specific tools for specialized use cases

Rate Limiting: Configure request limits based on usage patterns:

• Free Plan: 60 requests/hour maximum
• Starter Plan: Up to 600 requests/hour
• Professional Plan: Up to 3,000 requests/hour
• Enterprise Plan: Custom limits available

Integrating with AI Tools

Claude Desktop Setup

Prerequisites:

• Claude Desktop application (latest version)
• KnowSync API key with appropriate permissions
• User identification for team tracking

Configuration:

1. Get Your Server URL: https://www.knowsync.ai/api/mcp
2. Add to Claude Desktop Settings:

{
  "mcpServers": {
    "knowsync": {
      "url": "https://www.knowsync.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY",
        "X-User-Id": "your_user_id_here"
      }
    }
  }
}

Cursor IDE Integration

Setup Instructions:

1. Open Cursor Settings (Cmd/Ctrl + ,)
2. Navigate to MCP Section
3. Add KnowSync Server:

{
  "mcpServers": {
    "knowsync": {
      "url": "https://www.knowsync.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY",
        "X-User-Id": "your_user_id_here"
      }
    }
  }
}

VS Code Integration

Using MCP Extension:

1. Install MCP Extension for VS Code
2. Configure in settings.json:

{
  "mcp.servers": {
    "knowsync": {
      "url": "https://www.knowsync.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY",
        "X-User-Id": "your_user_id_here"
      }
    }
  }
}

Claude Code Setup

Prerequisites:

• Claude Code CLI installed (install via npm install -g @anthropic-ai/claude-code or follow official installation guide)
• KnowSync API key with appropriate permissions
• Your KnowSync user/email ID (found in profile settings)

Configuration:

1. Add KnowSync MCP Server using the Claude CLI:

• with User ID:

claude mcp add --transport http knowsync https://www.knowsync.ai/api/mcp \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "X-User-Id: your_user_id_here"

• with User Email:

claude mcp add --transport http knowsync https://www.knowsync.ai/api/mcp \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "X-User-Email: your_user_email_here"

2. Verify the Configuration:

claude mcp list

This should show the knowsync server in the list.

Note: Ensure your API key has the necessary tool permissions. Replace placeholders with actual values.

Team Member Tracking

Required Headers: All MCP requests must include user identification for proper attribution:

• X-User-Id: Your KnowSync user ID (found in profile settings)
• X-User-Email: Your registered email address

Why It's Required:

• Track individual team member usage
• Generate per-user analytics and insights
• Ensure proper audit trails
• Enable usage-based billing and limits

Real-World MCP Usage Examples

Development Workflow Integration

Scenario 1: Code Review Assistant

Use Case: AI agent helps during code reviews by accessing your team's coding standards and best practices.

# Query for coding standards
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: your_user_id" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "knowsync_query",
      "arguments": {
        "query": "What are our React component naming conventions and prop validation requirements?",
        "mode": "retrieve",
        "limit": 4
      }
    }
  }'

AI Agent Integration: Configure Claude Code to use this for instant access to your team's standards during development.

Scenario 2: Onboarding New Team Members

Use Case: Automatically populate knowledge base with latest framework documentation for new hires.

# Discover and add latest documentation
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: your_user_id" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "knowsync_manage",
      "arguments": {
        "operation": "discover",
        "query": "Next.js 15 App Router migration guide 2024",
        "options": {
          "maxResults": 8,
          "maxUrls": 4,
          "relevanceThreshold": 0.8
        }
      }
    }
  }'

Expected Response with API Consumption:

{
  "success": true,
  "documentsCreated": 4,
  "apiUnitsConsumed": 8,
  "message": "Successfully discovered and processed 4 documents into knowledge base (8 API units consumed)"
}

Note: 4 URLs × 2 units each (1 crawl + 1 processing) = 8 total API units

Customer Support Enhancement

Scenario 3: Instant Support Documentation Access

Use Case: Support agents get instant answers from product documentation while helping customers.

# Search for troubleshooting information
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: support_agent_123" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "knowsync_query",
      "arguments": {
        "query": "Customer getting 401 errors during payment processing, what are the common causes and solutions?",
        "mode": "auto",
        "limit": 6
      }
    }
  }'

Benefits: 60-85% faster response time due to caching, AI-enhanced relevance ranking shows most helpful solutions first.

Product Management Workflows

Scenario 4: Competitive Analysis Research

Use Case: Product managers research competitor features and industry trends.

# Discover latest competitive analysis
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: product_manager" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 4,
    "method": "tools/call",
    "params": {
      "name": "knowsync_manage",
      "arguments": {
        "operation": "discover",
        "query": "SaaS pricing strategy trends 2024 freemium models",
        "options": {
          "maxResults": 10,
          "maxUrls": 5,
          "relevanceThreshold": 0.7
        }
      }
    }
  }'

Scenario 5: Feature Requirements Lookup

Use Case: Quickly find existing feature specifications and requirements during planning.

# Search existing requirements
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: product_manager" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 5,
    "method": "tools/call",
    "params": {
      "name": "knowsync_query",
      "arguments": {
        "query": "user authentication flow requirements two-factor authentication implementation",
        "mode": "retrieve",
        "filters": {
          "contentTypes": ["documents"],
          "documentIds": ["spec_docs_collection"]
        }
      }
    }
  }'

Sales and Marketing Support

Scenario 6: Sales Enablement

Use Case: Sales team accesses product information and competitive positioning during customer calls.

# Quick product feature lookup
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: sales_rep" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 6,
    "method": "tools/call",
    "params": {
      "name": "knowsync_query",
      "arguments": {
        "query": "What security certifications do we have? SOC 2 compliance status enterprise security features",
        "mode": "search",
        "limit": 5
      }
    }
  }'

Knowledge Base Maintenance

Scenario 7: Content Gap Analysis

Use Case: Identify what documentation exists and what needs to be created.

# Audit existing documentation
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: content_manager" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 7,
    "method": "tools/call",
    "params": {
      "name": "knowsync_manage",
      "arguments": {
        "operation": "list",
        "filters": {
          "limit": 50,
          "status": "ready",
          "contentType": "markdown"
        }
      }
    }
  }'

Scenario 8: Adding Industry Documentation

Use Case: Keep knowledge base current with latest industry standards and frameworks.

# Add specific technical documentation
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: tech_writer" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 8,
    "method": "tools/call",
    "params": {
      "name": "knowsync_manage",
      "arguments": {
        "operation": "crawl",
        "url": "https://nextjs.org/docs/app/building-your-application/authentication",
        "options": {
          "respectRobots": true,
          "timeout": 45,
          "followLinks": false
        }
      }
    }
  }'

Why KnowSync MCP is Revolutionary

The Power Difference

Traditional documentation systems make you hunt for information. KnowSync MCP makes information come to you:

Before KnowSync MCP:

• Switch between tools to search documentation
• Repeat searches for similar questions
• Manually piece together information from multiple sources
• Wait 2-5 seconds per search
• Get results that may or may not be relevant

With KnowSync MCP:

• AI agents automatically access your knowledge base
• 60-85% faster responses through intelligent caching
• AI understands context and provides exactly what you need
• Session memory maintains conversation context
• Results ranked by AI for maximum relevance

Real Impact on Your Workflow

# Traditional approach: Manual search in documentation
# Time: 2-5 minutes per question
# Result: May not find the right answer

# KnowSync MCP approach: AI agent instantly knows
# Time: 2-5 seconds per question
# Result: Contextual, accurate, source-cited answers

Example: A developer asking "How do we handle authentication?" gets not just the auth docs, but specifically the sections relevant to their current project context, with follow-up suggestions, in under 2 seconds.

Advanced Integration Patterns

Session-Aware Conversations

The AI remembers context across queries in the same session, enabling natural follow-up questions:

# First query
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: developer_session_123" \
  -d '{
    "params": {
      "name": "knowsync_query",
      "arguments": {
        "query": "How do we handle user authentication in our React apps?"
      }
    }
  }'

# Follow-up query (AI maintains context)
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: developer_session_123" \
  -d '{
    "params": {
      "name": "knowsync_query",
      "arguments": {
        "query": "What about logout and session management for that?"
      }
    }
  }'

Performance Optimization Examples

Demonstrate the power of intelligent caching:

# First time query (full processing)
time curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: your_user_id" \
  -d '{
    "params": {
      "name": "knowsync_query",
      "arguments": {
        "query": "deployment pipeline configuration Docker containerization"
      }
    }
  }'
# Response time: ~800ms

# Similar query (cached response)
time curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: your_user_id" \
  -d '{
    "params": {
      "name": "knowsync_query",
      "arguments": {
        "query": "how to configure deployment pipelines with Docker containers"
      }
    }
  }'
# Response time: ~120ms (85% faster!)

Transform Your Team's Productivity

Before vs After KnowSync MCP

| Scenario | Traditional Method | With KnowSync MCP | Time Saved | |----------|-------------------|-------------------|------------| | Code Review | Search through docs manually | AI agent instantly cites coding standards | 90% faster | | Customer Support | Look up troubleshooting guides | AI provides exact solution steps | 85% faster | | Onboarding | Send links to documentation | AI answers specific questions contextually | 95% faster | | Product Planning | Research competitor features manually | AI discovers and analyzes latest trends | 80% faster |

The Compound Effect

Week 1: Your team saves 2-3 hours per day on documentation searches Month 1: 40-60 hours saved per team member Year 1: Each team member gains back 2-3 weeks of productive time

Real User Impact Stories

Development Team: "Instead of spending 30 minutes searching for our API patterns, Claude Code instantly shows me exactly what I need. I can focus on building instead of hunting."

Support Team: "Customer questions that used to take 10 minutes to research now get answered in 30 seconds. Our response quality improved while our response time dropped dramatically."

Product Team: "Research that used to take hours now happens in minutes. We can analyze competitive features, find requirements, and make decisions faster than ever."

Getting Started is Simple

1. Create API Key (2 minutes)
2. Connect your AI agent (Claude, Cursor, VS Code)
3. Start asking questions - that's it!

The power isn't in the technology - it's in how it transforms your daily work from searching to creating.

Usage Analytics and Monitoring

MCP Dashboard Features

API Key Management:

• Create, edit, and delete API keys
• Monitor usage statistics per key
• Configure permissions and rate limits
• View request history and patterns

Usage Analytics:

• Real-time request metrics by tool
• Success/error rates and response times
• Per-user attribution and team insights
• Historical trends and usage patterns

Settings Configuration:

• Web crawling limits and timeout settings
• Domain allow/block lists for web discovery
• Content type filtering preferences
• Rate limiting and security controls

Team Usage Tracking

Individual Analytics:

• Track which team members use MCP tools
• Monitor adoption patterns across the organization
• Identify power users and training needs
• Generate usage reports for management

Request Attribution: All MCP requests require user identification headers:

• X-User-Id: Direct user ID attribution
• X-User-Email: Email-based user attribution
• Requests without user headers are rejected
• Complete audit trail for compliance

Security and Access Control

Authentication System

API Key Security:

• Bcrypt hashing for stored keys
• Automatic key rotation capabilities
• Rate limiting per key to prevent abuse
• Real-time monitoring for suspicious activity

Permission Model:

• Tool-level permissions (granular access control)
• Organization-based access restrictions
• Plan-based feature availability
• Custom permission combinations

Enterprise Security (Enterprise Plans)

Advanced Features:

• IP-based access restrictions
• Single Sign-On (SSO) integration
• Audit logs for compliance requirements
• Custom security policies and controls

Data Protection:

• TLS encryption for all communications
• Secure storage of API keys and user data
• GDPR and CCPA compliance features
• Regular security audits and updates

Troubleshooting

Common Issues

Connection Problems:

• Error: AI agent can't connect to MCP server
• Solutions:
  • Verify API key is correct and hasn't expired
    • Confirm your domain URL is accessible (not localhost for remote tools)
    • Check that user identification headers are included
    • Review API key permissions for required tools

Authentication Errors:

• Error: "Unauthorized" or "User identification required"
• Solutions:
  • Include X-User-Id or X-User-Email header in all requests
    • Verify the user ID/email exists in your organization
    • Regenerate API key if necessary
    • Check API key has appropriate tool permissions

Rate Limiting:

• Error: "Rate limit exceeded"
• Solutions:
  • Review current usage in MCP dashboard
    • Adjust rate limits for your API key
    • Consider upgrading your plan for higher limits
    • Implement request throttling in your application

Tool Permission Errors:

• Error: "Permission denied for tool X"
• Solutions:
  • Edit API key permissions in MCP dashboard
    • Ensure your plan includes access to advanced tools
    • Contact support for plan-specific limitations

Testing Your MCP Server

Health Check:

# Test server connectivity
curl https://www.knowsync.ai/api/mcp

# Expected response includes server info and available tools

Tool Testing:

# Test initialize method
curl -X POST https://www.knowsync.ai/api/mcp \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-User-Id: your_user_id" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2024-11-05",
      "capabilities": {"tools": true},
      "clientInfo": {"name": "test-client", "version": "1.0.0"}
    }
  }'

Future MCP Tools

KnowSync is actively developing additional MCP tools planned for 2025:

Phase 1 (Q1 2025):

• knowsync_summarize: Generate smart summaries of documents
• knowsync_bulk_operations: Perform batch operations on multiple documents
• knowsync_compare: Compare documents for similarities and differences

Phase 2 (Q2 2025):

• knowsync_analytics: Get usage insights and knowledge base analytics
• knowsync_quality_check: Analyze and improve content quality

See our MCP Tools Roadmap for complete details.

Getting Support

Documentation:

• Complete MCP testing guide with real examples
• API reference documentation for all tools
• Integration guides for popular AI platforms

Support Channels:

• Starter/Professional: Email support with MCP expertise
• Enterprise: Dedicated MCP integration support
• All Plans: Community forums and documentation

Custom Integration: Enterprise customers can work with our team for custom MCP tool development and advanced integration patterns.

🚀 Ready to Connect Your AI Tools?

Start by creating your first API key in the MCP dashboard, then test the connection with a simple search query. Remember to include user identification headers for proper team attribution.