Skip to main content
Glama
Ahmed-Mansy-Mansico

MCP Task

by Ahmed-Mansy-Mansico
OverviewSchemaRelated ServersScoreDiscussions
Python
Remote

MCP Task - Universal ERPNext MCP Connector

A comprehensive Model Context Protocol (MCP) connector for ERPNext that enables LLMs to interact seamlessly with any ERPNext instance through standardized tools and advanced permission controls.

License: MIT Python Version Frappe Version

🎯 Overview

MCP Task is a general-purpose MCP connector that transforms any ERPNext instance into an AI-accessible business system. It provides:

  • 🔌 Universal DocType Support: Works with any ERPNext DocType without configuration

  • 🛡️ Advanced Permission Model: Field-level, operation-level, and conditional access controls

  • 🚀 Complete CRUD Operations: Create, Read, Update, Delete with full validation

  • 🎨 Web Chat Interface: Built-in chat widget for direct LLM interaction

  • 📊 Comprehensive Auditing: Complete activity logging and permission tracking

  • ⚡ Production Ready: Enterprise-grade security, error handling, and performance

🌟 Key Features

🔧 Complete ERPNext Integration

  • Full CRUD Operations: Create, Read, Update, Delete any document type

  • Intelligent Search: Text-based search across all document fields

  • Flexible Filtering: Query documents with complex filter conditions

  • DocType Agnostic: Works with standard and custom DocTypes automatically

🛡️ Advanced Security & Permissions

  • Multi-Level Access Control: User roles, DocType permissions, field restrictions

  • Conditional Access: Python-based rules for dynamic permission evaluation

  • Audit Trail: Complete logging of all LLM interactions and data access

  • Field-Level Security: Hide sensitive fields from LLM access

🎨 User Experience

  • Web Chat Interface: Floating chat widget integrated into ERPNext UI

  • Real-time Responses: Instant feedback with loading indicators

  • Conversation History: Persistent chat sessions per user

  • Mobile Responsive: Works seamlessly on desktop and mobile devices

🏗️ Architecture

System Overview

graph TB
    LLM[LLM Client<br/>Claude, GPT, etc.] --> MCP[MCP Protocol Handler]
    MCP --> TR[Tool Registry]
    TR --> TOOLS[Document Tools<br/>CRUD Operations]
    TOOLS --> PERM[Permission Engine]
    PERM --> ERP[ERPNext Database]
    
    PERM --> CONFIG[Permission Configuration]
    CONFIG --> FIELD[Field Restrictions]
    CONFIG --> OP[Operation Controls]  
    CONFIG --> COND[Condition Scripts]
    
    MCP --> AUDIT[Audit Logger]
    MCP --> CHAT[Chat Interface]
    
    subgraph "Security Layers"
        PERM
        CONFIG
        AUDIT
    end

Core Components

1. MCP Protocol Handler (api/__init__.py)

  • JSON-RPC 2.0 Compliance: Full MCP protocol implementation

  • Request Routing: Handles initialize, tools/list, tools/call methods

  • Error Management: Comprehensive error handling with proper status codes

  • Authentication: Integration with ERPNext session management

2. Tool Registry System (core/)

  • Dynamic Discovery: Automatic tool loading and registration

  • Permission Integration: Built-in permission validation for each tool

  • Extensible Architecture: Easy addition of custom tools

  • Metadata Management: Tool descriptions and input schemas

3. Document Tools (tools/)

  • create_document: Create any ERPNext document with validation

  • get_document: Retrieve document data with field filtering

  • list_documents: Query documents with flexible filters

  • search_documents: Full-text search across document types

  • update_document: Modify document fields with validation

  • delete_document: Remove documents with dependency checks

4. Advanced Permission Engine

  • MCP Permission Configuration: Configurable access control DocType

  • Multi-Level Security: Role, DocType, field, and operation controls

  • Condition Scripts: Python-based dynamic permission evaluation

  • Field Filtering: Automatic removal of restricted fields from responses

5. Web Interface (public/js/mcp_task.js)

  • Floating Chat Widget: Non-intrusive interface integrated into ERPNext

  • Real-time Communication: WebSocket-based chat with loading indicators

  • Conversation Persistence: User-specific chat history management

  • Responsive Design: Mobile and desktop compatibility

6. Audit & Logging System

  • MCP Chat Log: Complete interaction logging for compliance

  • Permission Tracking: Detailed logs of access control decisions

  • Performance Monitoring: Request timing and error rate tracking

  • Security Auditing: Failed access attempts and policy violations

🚀 Installation & Setup

Prerequisites

  • ERPNext v15+ or Frappe Framework v15+

  • Python 3.10+

  • Node.js 18+ (for building assets)

  • Redis (for background jobs and caching)

Step 1: Install the App

# Clone the repository
cd frappe-bench
bench get-app https://github.com/yourusername/mcp_task

# Install on your site
bench --site your-site.com install-app mcp_task

# Migrate database
bench --site your-site.com migrate

# Build and restart
bench build --app mcp_task
bench restart

Step 2: Configure Permissions

Basic Setup (All Users)

# Enable MCP access for all users (basic setup)
bench --site your-site.com execute "frappe.db.set_single_value('System Settings', 'enable_mcp_chat', 1)"

Advanced Setup (Role-Based)

  1. Create MCP Roles (via Setup > Users and Permissions > Role):

    • MCP Admin: Full access to configuration and tools

    • MCP User: Limited access to standard operations

  2. Assign Roles to users through User management

Step 3: Environment Variables

Create a .env file in your bench directory:

# MCP Configuration
MCP_ENABLED=1
MCP_DEBUG=0
MCP_LOG_LEVEL=INFO

# Security Settings
MCP_RATE_LIMIT=100  # Requests per minute per user
MCP_SESSION_TIMEOUT=3600  # Session timeout in seconds

# Optional: External LLM Integration
OPENAI_API_KEY=your_openai_key_here
CLAUDE_API_KEY=your_claude_key_here

Step 4: Basic Configuration Test

# Test MCP endpoint
curl -X POST http://your-site.com/api/method/mcp_task.api.handle_mcp_request \
  -H "Content-Type: application/json" \
  -H "Authorization: token your_api_key:your_api_secret" \
  -d '{
    "jsonrpc": "2.0",
    "method": "initialize", 
    "params": {"protocolVersion": "2024-11-05"},
    "id": 1
  }'

Step 5: Chat Interface Setup

The chat interface is automatically available after installation. Users will see a chat icon in the navbar when logged in.

Troubleshooting: If chat icon doesn't appear:

# Clear cache and rebuild
bench --site your-site.com clear-cache
bench build --app mcp_task
bench restart

🔒 Permission Model & Access Control

Overview

MCP Task implements a multi-layered security model that allows granular control over LLM access to your ERPNext data:

  1. User Authentication: Standard ERPNext login required

  2. Role-Based Access: ERPNext role system integration

  3. DocType Permissions: Native ERPNext permission system

  4. MCP-Specific Controls: Advanced field and operation restrictions

Permission Configuration

Creating Permission Rules

Navigate to Setup > MCP Task > MCP Permission Configuration to create custom access rules:

# Example: Restrict Sales User to read-only Customer data
{
  "title": "Sales User Customer Access",
  "doctype_name": "Customer", 
  "user_roles": "Sales User",
  "operation_restrictions": {
    "allowed_operations": ["read", "list", "search"],
    "blocked_operations": ["create", "update", "delete"]
  },
  "field_restrictions": {
    "blocked_fields": ["credit_limit", "payment_terms"]
  }
}

Field-Level Restrictions

Control which fields are accessible to the LLM:

{
  "field_restrictions": {
    "allowed_fields": ["customer_name", "customer_group", "territory"],
    "blocked_fields": ["credit_limit", "outstanding_amount", "payment_terms"]
  }
}

Condition-Based Access

Use Python scripts for dynamic permission evaluation:

# Condition Script Example: Only allow access to own records
if doc and doc.get("owner") == user:
    result = True
else:
    result = False

# Complex example: Time-based restrictions
import datetime
current_hour = datetime.datetime.now().hour
if current_hour < 9 or current_hour > 17:  # Business hours only
    result = False
else:
    result = True

Permission Examples

Example 1: Basic User Restrictions

{
  "title": "Standard User Access",
  "user_roles": "Employee, Desk User",
  "operation_restrictions": {
    "allowed_operations": ["read", "search", "list"]
  },
  "field_restrictions": {
    "blocked_fields": ["base_amount", "outstanding_amount", "credit_limit"]
  }
}

Example 2: Department-Specific Access

{
  "title": "HR Department Access", 
  "doctype_name": "Employee",
  "user_roles": "HR User, HR Manager",
  "field_restrictions": {
    "allowed_fields": ["employee_name", "department", "designation", "reports_to"]
  },
  "condition_script": "result = frappe.get_roles(user).contains('HR Manager') or doc.get('department') == frappe.db.get_value('Employee', {'user_id': user}, 'department')"
}

Example 3: Financial Data Protection

{
  "title": "Accounts Restricted Access",
  "tool_names": "get_document, list_documents", 
  "operation_restrictions": {
    "conditions": {
      "financial_doctypes": ["Sales Invoice", "Purchase Invoice", "Payment Entry"],
      "require_role": "Accounts User"
    }
  },
  "condition_script": """
# Only accounts users can access financial documents
if doctype in ['Sales Invoice', 'Purchase Invoice', 'Payment Entry']:
    result = 'Accounts User' in frappe.get_roles(user)
else:
    result = True
  """
}

Security Best Practices

1. Principle of Least Privilege

  • Start with minimal permissions and add as needed

  • Use role-based restrictions rather than user-specific rules

  • Regularly audit permission configurations

2. Field Sensitivity Classification

# High Sensitivity (Always Block)
HIGH_SENSITIVITY = [
    "bank_account", "iban", "swift_number",
    "salary", "ctc", "password", "api_key"
]

# Medium Sensitivity (Role-Based Access)
MEDIUM_SENSITIVITY = [
    "credit_limit", "outstanding_amount", 
    "employee_id", "phone", "email"
]

3. Audit Configuration

  • Enable detailed logging for all permission decisions

  • Monitor failed access attempts

  • Regular review of permission effectiveness

🎯 API Usage Examples

LLM Prompt Examples

Document Creation

"Create a new Customer with the name 'Tech Solutions Inc', customer group 'Corporate', and territory 'India'. Set the customer type to 'Company'."

MCP Request:

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "create_document",
    "arguments": {
      "doctype": "Customer",
      "data": {
        "customer_name": "Tech Solutions Inc",
        "customer_group": "Corporate", 
        "territory": "India",
        "customer_type": "Company"
      }
    }
  },
  "id": 1
}

Document Retrieval with Field Filtering

"Show me the customer details for CUST-001, but hide any financial information."

MCP Response (with field restrictions applied):

{
  "jsonrpc": "2.0", 
  "result": {
    "content": [{
      "type": "text",
      "text": {
        "customer_name": "Tech Solutions Inc",
        "customer_group": "Corporate",
        "territory": "India",
        "customer_type": "Company"
        // Sensitive fields like credit_limit filtered out
      }
    }]
  },
  "id": 1
}

Complex Searches

"Find all Sales Orders from the last 30 days where the customer is from Mumbai territory and the order value is above 50,000."

MCP Request:

{
  "jsonrpc": "2.0",
  "method": "tools/call", 
  "params": {
    "name": "list_documents",
    "arguments": {
      "doctype": "Sales Order",
      "filters": {
        "creation": [">=", "2024-12-15"],
        "territory": "Mumbai",
        "grand_total": [">", 50000]
      },
      "fields": ["name", "customer", "grand_total", "delivery_date"]
    }
  },
  "id": 1
}

⚠️ Security Considerations

Data Protection

  • Encryption in Transit: All MCP communications use HTTPS/WSS

  • Session Management: ERPNext session tokens with configurable timeouts

  • API Rate Limiting: Configurable request limits per user/IP

  • Audit Logging: Complete trail of all LLM interactions

Failure Modes & Mitigation

1. Permission Bypass Attempts

  • Risk: LLM attempts to access restricted data

  • Mitigation: Multi-layer validation, default-deny policies

  • Monitoring: Alert on permission failures

2. Data Leakage via Field Filtering

  • Risk: Sensitive data exposed through related fields

  • Mitigation: Deep field analysis, cascading restrictions

  • Example: Block customer.credit_limit when customer data is filtered

3. Condition Script Vulnerabilities

  • Risk: Malicious Python code in condition scripts

  • Mitigation: Sandboxed execution, restricted imports

  • Validation: Syntax checking, security reviews

4. Large Data Extraction

  • Risk: LLM queries return excessive data volumes

  • Mitigation: Result size limits, pagination controls

  • Configuration: MAX_RESULTS_PER_QUERY = 1000

Security Monitoring

# Example monitoring alerts
SECURITY_ALERTS = {
    "permission_failures": {
        "threshold": 10,  # failures per hour
        "action": "notify_admin"
    },
    "large_queries": {
        "threshold": 5000,  # records per query
        "action": "log_and_limit"
    },
    "sensitive_field_access": {
        "fields": ["salary", "credit_limit", "bank_account"],
        "action": "audit_log"
    }
}

🛠️ Development & Customization

Adding Custom Tools

  1. Create Tool Class (tools/my_custom_tool.py):

from typing import Any
from mcp_task.core.base_tool import BaseTool
import frappe

class MyCustomTool(BaseTool):
    def __init__(self):
        super().__init__()
        self.name = "my_custom_tool"
        self.description = "Custom business logic tool"
        self.requires_permission = "My Custom DocType"
        self.inputSchema = {
            "type": "object",
            "properties": {
                "param1": {"type": "string", "description": "First parameter"},
                "param2": {"type": "integer", "description": "Second parameter"}
            },
            "required": ["param1"]
        }
    
    def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
        try:
            # Your custom logic here
            result = self.perform_custom_operation(arguments)
            return {"success": True, "data": result}
        except Exception as e:
            return {"success": False, "error": str(e)}
    
    def perform_custom_operation(self, args):
        # Implement your business logic
        pass

  1. Register Tool (in core/tool_registry.py):

from mcp_task.tools.my_custom_tool import MyCustomTool

# Add to load_tools method
self.register_tool(MyCustomTool())

Extending Permission System

  1. Custom Permission Validators:

# mcp_task/permissions/custom_validators.py
def validate_customer_territory(user, doc_data):
    """Only allow access to customers in user's territory"""
    user_territory = frappe.db.get_value("Employee", 
        {"user_id": user}, "territory")
    return doc_data.get("territory") == user_territory

  1. Plugin-Based Architecture:

# mcp_task/plugins/custom_business_rules.py
class CustomBusinessRules:
    def apply_restrictions(self, tool_name, user, doc_data):
        # Custom business logic
        pass

Chat Interface Customization

CSS Styling (public/css/custom_chat.css):

.mcp-chat-widget {
    /* Custom positioning */
    bottom: 20px;
    right: 20px;
    
    /* Brand colors */
    --primary-color: #1976d2;
    --secondary-color: #424242;
}

.mcp-message-bubble.user {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
}

JavaScript Extensions (public/js/custom_chat.js):

// Extend chat functionality
frappe.ready(() => {
    // Custom message preprocessing
    window.mcpChat.preprocessMessage = function(message) {
        // Add custom logic
        return message;
    };
    
    // Custom response formatting
    window.mcpChat.formatResponse = function(response) {
        // Add charts, tables, etc.
        return response;
    };
});

📋 Complete API Reference

MCP Protocol Endpoints

mcp_task.api.handle_mcp_request

Main MCP protocol handler supporting JSON-RPC 2.0 specification.

Supported Methods:

  • initialize: Establish MCP connection

  • tools/list: Get available tools for current user

  • tools/call: Execute a specific tool

  • ping: Connection health check

Available Tools

create_document

Create new ERPNext documents with validation.

Input Schema:

{
  "doctype": "string (required)",
  "data": "object (required)", 
  "submit": "boolean (optional)"
}

Example:

{
  "doctype": "Customer",
  "data": {
    "customer_name": "ABC Corp",
    "customer_type": "Company"
  }
}

get_document

Retrieve document by DocType and name.

Input Schema:

{
  "doctype": "string (required)",
  "name": "string (required)"
}

list_documents

Query documents with flexible filtering.

Input Schema:

{
  "doctype": "string (required)",
  "filters": "object (optional)",
  "fields": "array (optional)", 
  "limit": "integer (optional, default: 20)",
  "order_by": "string (optional)"
}

Example:

{
  "doctype": "Sales Order", 
  "filters": {
    "customer": "CUST-001",
    "docstatus": 1
  },
  "fields": ["name", "customer", "grand_total"],
  "order_by": "creation desc"
}

search_documents

Full-text search across document fields.

Input Schema:

{
  "doctype": "string (required)",
  "search_text": "string (required)",
  "fields": "array (optional)"
}

update_document

Modify existing document fields.

Input Schema:

{
  "doctype": "string (required)",
  "name": "string (required)", 
  "data": "object (required)"
}

delete_document

Remove documents with dependency validation.

Input Schema:

{
  "doctype": "string (required)",
  "name": "string (required)",
  "force": "boolean (optional, default: false)"
}

Chat Interface APIs

mcp_task.api.send_chat_message

Send message through web interface.

Parameters:

  • message: Chat message text

  • conversation_id: Optional conversation ID

mcp_task.api.get_conversation_history

Retrieve chat history for current user.

Parameters:

  • conversation_id: Optional specific conversation

  • limit: Number of messages to retrieve

Permission Configuration APIs

check_mcp_permissions

Validate access for specific context.

from mcp_task.mcp_task.doctype.mcp_permission_configuration.mcp_permission_configuration import check_mcp_permissions

result = check_mcp_permissions(
    user="user@example.com",
    tool_name="get_document",
    doctype_name="Customer", 
    operation="read",
    doc_data={"customer_name": "ABC Corp"}
)

🔧 Troubleshooting

Common Issues

1. Chat Icon Not Appearing

# Check if app is installed
bench --site your-site.com list-apps

# Rebuild assets
bench build --app mcp_task
bench restart

# Check browser console for JavaScript errors

2. Permission Denied Errors

# Check user roles
frappe.get_roles("user@example.com")

# Verify DocType permissions
frappe.has_permission("Customer", "read", user="user@example.com")

# Check MCP permission configurations
frappe.get_all("MCP Permission Configuration", {"enabled": 1})

3. Tool Not Found

# Check tool registry
from mcp_task.core.tool_registry import get_tool_registry
registry = get_tool_registry()
print([tool["name"] for tool in registry.list_tools()])

4. Field Restrictions Not Applied

# Check permission configuration syntax
bench --site your-site.com console
>>> doc = frappe.get_doc("MCP Permission Configuration", "CONFIG-NAME")
>>> doc.validate_json_fields()

5. Performance Issues

# Enable query debugging
frappe.db.set_debug(True)

# Check slow queries in logs
tail -f logs/frappe.log | grep "SLOW QUERY"

# Monitor memory usage
psutil.virtual_memory()

Debug Mode

Enable detailed logging for troubleshooting:

# Enable debug mode
export MCP_DEBUG=1
bench restart

# Check debug logs
tail -f logs/mcp_task.log

Log Analysis

# Analyze permission failures
frappe.db.sql("""
    SELECT user, tool_name, COUNT(*) as failures
    FROM `tabMCP Chat Log` 
    WHERE success = 0 
    AND creation >= NOW() - INTERVAL 1 DAY
    GROUP BY user, tool_name
    ORDER BY failures DESC
""")

🚀 Performance Optimization

Caching Strategies

# Tool result caching
from frappe.utils import cint
cache_timeout = cint(frappe.conf.get("mcp_cache_timeout", 300))

@frappe.cache(ttl=cache_timeout)
def get_cached_document_list(doctype, filters):
    return frappe.get_all(doctype, filters)

Database Optimization

-- Add indexes for common queries
CREATE INDEX idx_mcp_chat_log_user_creation 
ON `tabMCP Chat Log`(user, creation);

CREATE INDEX idx_mcp_permission_config_enabled 
ON `tabMCP Permission Configuration`(enabled, doctype_name);

Memory Management

# Limit result set sizes  
MAX_RESULTS_PER_QUERY = 1000
MAX_FIELD_LENGTH = 10000

def apply_result_limits(results):
    if len(results) > MAX_RESULTS_PER_QUERY:
        results = results[:MAX_RESULTS_PER_QUERY]
    return results

� Monitoring & Analytics

Performance Metrics

# Built-in metrics collection
METRICS = {
    "requests_per_minute": "tools_called / time_window",
    "average_response_time": "sum(response_times) / request_count", 
    "error_rate": "failed_requests / total_requests",
    "permission_denials": "count(access_denied_events)"
}

Health Checks

# System health endpoint
curl -X POST http://your-site.com/api/method/mcp_task.api.handle_mcp_request \
  -d '{"jsonrpc": "2.0", "method": "ping", "id": 1}'

# Expected response
{"jsonrpc": "2.0", "result": {"status": "ok", "timestamp": "2024-01-14T12:00:00"}, "id": 1}

Usage Analytics

# Popular tools report
frappe.db.sql("""
    SELECT 
        tool_name,
        COUNT(*) as usage_count,
        AVG(CASE WHEN success=1 THEN 1 ELSE 0 END) as success_rate
    FROM `tabMCP Chat Log`
    WHERE creation >= DATE_SUB(NOW(), INTERVAL 30 DAY)
    GROUP BY tool_name
    ORDER BY usage_count DESC
""")

🤝 Contributing

We welcome contributions! Please follow these guidelines:

Development Setup

# Fork and clone the repository
git clone https://github.com/yourusername/mcp_task
cd mcp_task

# Install development dependencies
pip install -e ".[dev]"
pre-commit install

# Run tests
python -m pytest tests/

Code Standards

  • Python: Follow PEP 8, use type hints

  • JavaScript: Use ESLint configuration

  • Documentation: Update README and docstrings

  • Tests: Add tests for new features

Pull Request Process

  1. Create Feature Branch: git checkout -b feature/your-feature

  2. Write Tests: Ensure >80% code coverage

  3. Update Documentation: Include examples and API docs

  4. Submit PR: With detailed description and test results

📄 License

MIT License

Copyright (c) 2025 MCP Task Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

🆘 Support & Community

Getting Help

Community

Commercial Support

Professional implementation and support services available:

  • Implementation Consulting: Custom deployment and configuration

  • Training & Workshops: Team training on MCP integration

  • Custom Development: Tailored tools and extensions

  • Enterprise Support: SLA-backed support plans

Contact: enterprise@yourcompany.com

Made with ❤️ for the ERPNext Community

Transform your ERPNext into an AI-powered business system with MCP Task - the universal connector for intelligent automation.

🎨 UI Components

Chat Widget Features

  • Floating Interface: Non-intrusive chat overlay

  • Message Bubbles: User and assistant message styling

  • Typing Indicators: Shows when AI is processing

  • Responsive Design: Adapts to mobile screens

  • Conversation History: Persistent chat sessions

Integration Points

  • Navbar Icon: Easy access from any page

  • Auto-loading: Initializes on page load

  • Event Handling: Keyboard shortcuts and click handlers

🔧 Configuration

Enable Chat for Users

The chat is available to all logged-in users by default. You can customize access by modifying permissions in the DocType settings.

Customize AI Responses

In api/__init__.py, modify the _process_with_llm function to integrate with your preferred LLM provider (OpenAI, Claude, etc.).

📊 Monitoring

Chat Logs

All tool executions are logged in the MCP Chat Log DocType for:

  • Audit compliance

  • Performance monitoring

  • Error tracking

  • Usage analytics

Conversation Analytics

Monitor chat usage through:

  • Conversation counts per user

  • Popular tool usage

  • Error rates

  • Response times

🚀 Roadmap

  • Integration with external LLM APIs (OpenAI, Claude)

  • Advanced tool chaining and workflows

  • Voice chat capabilities

  • Multi-language support

  • Plugin architecture for custom tools

  • Advanced analytics dashboard

🤝 Contributing

  1. Fork the repository

  2. Create a feature branch

  3. Make your changes

  4. Add tests

  5. Submit a pull request

📄 License

MIT License - see LICENSE file for details.

🆘 Support

For issues and questions:

Installation

You can install this app using the bench CLI:

cd $PATH_TO_YOUR_BENCH
bench get-app $URL_OF_THIS_REPO --branch develop
bench install-app mcp_task

Contributing

This app uses pre-commit for code formatting and linting. Please install pre-commit and enable it for this repository:

cd apps/mcp_task
pre-commit install

Pre-commit is configured to use the following tools for checking and formatting your code:

  • ruff

  • eslint

  • prettier

  • pyupgrade

License

mit

This server cannot be installed

A
license - permissive license
-
quality - not tested
C
maintenance

How are these scores calculated?

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

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/Ahmed-Mansy-Mansico/MCP_LLM_Server_FOR_ERPNext'

If you have feedback or need assistance with the MCP directory API, please join our Discord server