# Project-05-MCP-Enterprise-Tools-Server

An MCP-based enterprise tools server that exposes company knowledge search and employee database lookup as callable tools. The project demonstrates how an AI client such as Cursor, Claude Desktop, or a custom Python MCP client can discover tools, call them through the Model Context Protocol, and return structured results.

This project currently includes a document-search tool backed by an existing RAG API and a SQLite query tool for employee data.

## Features

- MCP server built with `FastMCP`
- `search_documents` tool for company knowledge lookup through a RAG API
- `query_database` tool for SQLite employee database queries
- Local stdio MCP client for testing tool discovery and execution
- Cursor MCP configuration example
- Environment-based configuration for the RAG API URL
- JSON-formatted database responses
- Small sample employee database for quick testing

## Workflow

```text
User / MCP Client
      |
      v
MCP Server
      |
      +--> search_documents --> RAG API --> Company Knowledge
      |
      +--> query_database ----> SQLite ----> Employee Records
      |
      v
Tool Response
```

## Screenshots

### Cursor MCP Client Integration

![Cursor MCP Client Integration](Screenshots/cursor-mcp-client-integration.png)

### Database Query Tool

![Database Query Tool](Screenshots/query-database.png)

### Company Document Search Tool

![Company Document Search Tool](Screenshots/search-documents.png)

## Project Structure

```text
.
|-- db.py                 # Creates and seeds the sample employees SQLite database
|-- employees.db          # Local SQLite database generated for testing
|-- mcp_client.py         # CLI MCP client using stdio transport
|-- mcp_config.json       # MCP server configuration example
|-- mcp_server.py         # FastMCP server with enterprise tools
|-- requirements.txt      # Python dependencies
|-- README.md             # Project documentation
`-- Screenshots/          # Project screenshots
```

## Tools

### `search_documents`

Searches company documents by sending the user query to a RAG API.

Input:

```json
{
  "query": "what is refund duration?"
}
```

Output:

```text
Context: ...
Sources: ...
```

### `query_database`

Runs a SQL query on the local SQLite employee database and returns rows as formatted JSON.

Input:

```json
{
  "sql": "select * from employees"
}
```

Output:

```json
[
  {
    "id": 1,
    "name": "Harry",
    "salary": 50000,
    "department": "AI"
  }
]
```

## Setup

Clone the repository:

```bash
git clone https://github.com/Harry-GenAI/05-mcp-enterprise-tool-server.git
cd 05-mcp-enterprise-tool-server
```

Create and activate a virtual environment:

```bash
python -m venv venv
venv\Scripts\activate
```

Install dependencies:

```bash
pip install -r requirements.txt
```

Create a `.env` file:

```env
RAG_URL=http://localhost:8000/rag
```

Create the sample database:

```bash
python db.py
```

## Run MCP Client

Use the local CLI client to start the MCP server over stdio, list available tools, and call one of them:

```bash
python mcp_client.py
```

Example database query:

```text
Enter tool name: query_database
Enter SQL Query: select * from employees
```

Example document search:

```text
Enter tool name: search_documents
Enter search query: what is refund duration?
```

## Cursor MCP Configuration

Add this configuration to your Cursor MCP settings:

```json
{
  "mcpServers": {
    "enterprise_tools": {
      "command": "python",
      "args": ["mcp_server.py"]
    }
  }
}
```

After configuration, Cursor can discover and call:

- `search_documents`
- `query_database`

## Tech Stack

- Python
- Model Context Protocol
- FastMCP
- SQLite
- Requests
- python-dotenv
- Cursor MCP integration

## Future Upgrades

- Add SQL safety validation for read-only database access
- Support more enterprise tools such as CRM, HR, tickets, and policy lookup
- Add FastAPI wrapper for HTTP-based testing
- Return richer structured responses from the RAG tool
- Add authentication for protected internal tools
- Add automated tests for MCP tool calls

## Note

This project is for learning and demonstration. Keep `.env`, virtual environments, production databases, private documents, and secrets out of GitHub.