Enterprise MCP Server

A modular, security-focused Model Context Protocol (MCP) server that exposes enterprise-ready tools, prompts, and resources through a unified MCP interface.

📌 Project Overview

The Enterprise MCP Server is a Python-based MCP server built with FastMCP.

It provides a single interface for interacting with:

• 📁 Filesystem operations

• 🗄️ Database operations

• 🌐 REST APIs

• 🖥️ System utilities

• 🤖 AI generation

• 💬 Reusable MCP prompts

• 📚 MCP resources

The project follows a layered architecture with dedicated tools, services, validation, permission management, configuration, logging, and persistence components.

The implementation also includes database audit logging, SQL safety validation, explicit database execution permissions, authentication/authorization controls, and automated testing.

Related MCP server: AX Local Operations MCP Server

🚀 Project Status

Status: ✅ Implementation Complete

✨ Key Features

MCP Capabilities

• FastMCP-based server

• Idempotent server initialization

• Centralized tool registry

• 14 registered MCP tools

• 3 reusable MCP prompts

• 3 MCP resources

Security

• Authentication and authorization layer

• Read/write database separation

• Database execute permission control

• SQL query validation

• Multiple-statement rejection

• Destructive SQL pattern rejection

• Filesystem workspace restrictions

• Environment-based secret management

• Audit logging

Engineering

• Layered architecture

• Centralized configuration

• Structured application logging

• Service-layer separation

• Pydantic request/response models

• SQLAlchemy database integration

• Automated unit and persistence tests

• MCP Inspector validation

🏗️ Architecture

                         ┌──────────────────────┐
                         │     MCP Client       │
                         │   / MCP Inspector    │
                         └──────────┬───────────┘
                                    │
                                    ▼
                         ┌──────────────────────┐
                         │      FastMCP         │
                         │       Server         │
                         └──────────┬───────────┘
                                    │
             ┌──────────────────────┼──────────────────────┐
             │                      │                      │
             ▼                      ▼                      ▼
      ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
      │    Tools    │       │   Prompts   │       │  Resources  │
      └──────┬──────┘       └─────────────┘       └─────────────┘
             │
             ▼
      ┌───────────────────────────────────────────────┐
      │              Tool Registry / Layer            │
      └──────────────────────┬────────────────────────┘
                             │
             ┌───────────────┼────────────────┐
             │               │                │
             ▼               ▼                ▼
      ┌────────────┐  ┌────────────┐  ┌────────────┐
      │ Filesystem │  │  Database  │  │ REST API  │
      │  Service   │  │  Service   │  │  Service  │
      └────────────┘  └─────┬──────┘  └────────────┘
                             │
                             ▼
                       ┌────────────┐
                       │ SQLAlchemy │
                       └─────┬──────┘
                             │
                             ▼
                       ┌────────────┐
                       │  Database  │
                       │ audit_logs │
                       └────────────┘

                    ┌─────────────────┐
                    │   AI Service    │
                    │ Provider Layer  │
                    └─────────────────┘

🧩 MCP Tools

The server currently exposes 14 MCP tools.

📁 Filesystem Tools

🗄️ Database Tools

Database Query

Example:

{
  "query": "SELECT id, request_id, tool_name, status FROM audit_logs WHERE request_id = 'req-sample-002'",
  "parameters": {},
  "timeout": 30,
  "max_rows": 100
}

Database Execute

Example:

{
  "query": "CREATE TABLE IF NOT EXISTS mcp_test_table (id INTEGER PRIMARY KEY, message TEXT)",
  "parameters": {},
  "timeout": 30
}

Database Execute Security

Database execution is intentionally controlled.

Default permission policy:

QUERY    → ALLOWED
EXECUTE  → DENIED BY DEFAULT
HEALTH   → ALLOWED

Execution can be explicitly enabled through:

DATABASE_ALLOW_EXECUTE

The SQL must still pass execute-query validation.

🌐 REST API

The REST API layer handles request validation, timeout behavior, and HTTP error handling.

🖥️ System Utilities

Hash Example

Input:

{
  "algorithm": "sha256",
  "input": "abc"
}

Output:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

🤖 AI

AI provider configuration is managed through environment variables.

💬 MCP Prompts

The server provides 3 reusable MCP prompts.

Database Analysis Example

audit_logs

Incident Investigation Example

The database_query tool rejected a SELECT request with
UNSAFE_DATABASE_QUERY. Investigate whether the issue is
caused by SQL validation, permissions, or database availability.

📚 MCP Resources

The server provides 3 resources:

🗄️ Database Architecture

The database layer uses SQLAlchemy.

The main application table is:

audit_logs

Audit Log Schema

Example Audit Record

request_id : req-execute-test-001
client_id  : client-001
tool_name  : database_execute
operation  : insert
status     : success

🔐 Security Model

The project uses multiple security layers.

Client Request
      │
      ▼
Authentication
      │
      ▼
Authorization
      │
      ▼
Input Validation
      │
      ▼
Permission Policy
      │
      ▼
Service Execution
      │
      ▼
Audit Logging
      │
      ▼
Response

Database Query Security

database_query is read-only.

The validator rejects dangerous operations including:

INSERT
UPDATE
DELETE
DROP
ALTER
TRUNCATE
CREATE
GRANT
REVOKE
EXEC / EXECUTE
CALL

Multiple SQL statements are also rejected.

Example rejected input:

SELECT 1; SELECT 2;

The validator also protects against incorrectly interpreting SQL keywords contained inside quoted string values.

⚙️ Configuration

Application configuration is centralized in:

app/core/config.py

Configuration is loaded from environment variables and .env.

Important settings include:

APP_NAME
APP_VERSION
APP_ENV
DEBUG

HOST
PORT

LOG_LEVEL
LOG_FILE

SECRET_KEY

DATABASE_URL
DATABASE_ALLOW_EXECUTE

AI_PROVIDER
GROQ_API_KEY
ANTHROPIC_API_KEY
GEMINI_API_KEY
OPENAI_API_KEY

HTTP_TIMEOUT
MAX_RETRIES

⚠️ Secrets

Never commit:

.env
API keys
database credentials
secret keys

Use .env.example for safe configuration documentation.

📦 Project Structure

enterprise-mcp-server/
│
├── app/
│   │
│   ├── core/
│   │   ├── config.py
│   │   ├── constants.py
│   │   ├── logger.py
│   │   └── ...
│   │
│   ├── database/
│   │   ├── models.py
│   │   ├── session.py
│   │   └── ...
│   │
│   ├── server/
│   │   ├── mcp_server.py
│   │   ├── registry.py
│   │   ├── prompts.py
│   │   └── resources.py
│   │
│   ├── services/
│   │   ├── database_service.py
│   │   ├── filesystem_service.py
│   │   ├── rest_api_service.py
│   │   └── ...
│   │
│   └── tools/
│       ├── ai/
│       ├── database/
│       ├── filesystem/
│       ├── rest_api/
│       └── system/
│
├── tests/
│   ├── unit/
│   └── integration/
│
├── docs/
│   ├── api.md
│   ├── architecture.md
│   ├── database.md
│   ├── deployment.md
│   ├── security.md
│   └── tool-reference.md
│
├── data/
├── logs/
│
├── .env.example
├── .gitignore
├── pyproject.toml
└── README.md

🛠️ Installation

1. Clone the Repository

git clone <your-repository-url>
cd enterprise-mcp-server

2. Create Virtual Environment

Windows

python -m venv .venv
.venv\Scripts\Activate.ps1

Linux / macOS

python -m venv .venv
source .venv/bin/activate

3. Install Dependencies

Install the dependencies defined by the project configuration.

4. Configure Environment

Copy:

.env.example

to:

.env

Then configure the required values.

▶️ Running the Server

The primary server module is:

app/server/mcp_server.py

Verify Server Initialization

python -c "from app.server.mcp_server import initialize_server; initialize_server(); print('Server initialization successful')"

Expected final message:

MCP server initialized successfully.
Server initialization successful

Start the Server

Run the server using the project's configured server command.

🧪 Testing

Run the complete test suite:

pytest -v

Final Verified Result

101 passed

The test suite covers areas including:

• Safe database queries

• Unsafe query rejection

• Multiple SQL statement rejection

• Database permission policy

• Execute permission behavior

• Database configuration

• Query result serialization

• Database persistence

• Audit logging

• Authentication

• Authorization

• Tool behavior

• Service behavior

🔎 MCP Inspector Verification

The project was tested using MCP Inspector.

Verification includes:

Tools

14 tools

Prompts

3 prompts

Resources

3 resources

The Inspector was used to verify operations including:

• database_query

• database_execute

• database_health

• ai_generate

• rest_api_request

• system utilities

🧾 Example End-to-End Database Workflow

1. Create a test table

{
  "query": "CREATE TABLE IF NOT EXISTS mcp_test_table (id INTEGER PRIMARY KEY, message TEXT)",
  "parameters": {},
  "timeout": 30
}

2. Insert a record

{
  "query": "INSERT INTO mcp_test_table (message) VALUES ('MCP test record')",
  "parameters": {},
  "timeout": 30
}

3. Query the record

{
  "query": "SELECT id, message FROM mcp_test_table",
  "parameters": {},
  "timeout": 30,
  "max_rows": 100
}

This demonstrates the complete:

Execute → Persist → Query

workflow.

📊 Project Metrics

📖 Documentation

Detailed documentation is available in the docs/ directory:

• docs/api.md

• docs/architecture.md

• docs/database.md

• docs/deployment.md

• docs/security.md

• docs/tool-reference.md

🚧 Future Improvements

The current implementation is complete for the project scope.

Potential future enhancements:

• Production database migrations

• PostgreSQL deployment

• Docker / container deployment

• CI/CD pipeline

• Metrics and distributed tracing

• More granular per-client database permissions

• Parameterized MCP resource templates

• Expanded integration testing

• Production monitoring

• Additional AI provider abstractions

These are optional extensions rather than current project requirements.

🎯 What This Project Demonstrates

This project demonstrates practical experience with:

• Model Context Protocol

• FastMCP

• Python backend architecture

• API/service design

• Database engineering

• SQL security

• Permission systems

• Authentication and authorization

• Audit logging

• REST API integration

• AI integration

• Environment-based configuration

• Automated testing

• MCP Inspector

• Modular software design

👤 Author

ILA

Enterprise MCP Server — modular MCP tooling, security controls, database integration, AI integration, prompts, resources, and automated testing.

📄 License

Add the project's intended license here before publishing the repository publicly.