enterprise-mcp-server — MCP Server with RAG, Employee, and Ticket Tools

Overview

This project demonstrates how to build a custom Model Context Protocol (MCP) server that exposes reusable tools to AI applications.

Instead of an AI agent directly calling Python functions, MCP provides a standardized protocol that allows AI clients to discover and invoke external tools.

In this project, we build an MCP server that exposes four tool categories: calculator utilities, a RAG-powered document search tool (calling the RAG agent from project 02 over HTTP), an employee PTO lookup, and a ticket status lookup.

Related MCP server: AI Ops Hub

What is MCP?

Model Context Protocol (MCP) is an open protocol that enables AI applications to securely connect with external tools, data sources, and services.

Traditional approach:

AI Agent
   |
   v
Direct Python Function Calls

enterprise-mcp-server:

                MCP Client
                    |
                    |
             Authentication
                    |
                    v
             MCP Server
                    |
     +--------------+--------------+
     |              |              |
     v              v              v

  RAG Tool      Database Tool   API Tool

 search_docs    employee_db    system_health

The MCP server acts as a bridge between AI systems and external capabilities.

Architecture

The MCP server exposes enterprise capabilities as AI tools.

                 AI Client

                    |
                    |
                    v

              MCP Protocol

                    |
                    v

            Enterprise MCP Server

                    |
                    v

             RAG API Service
                    |
                    v

              Vector Database
                    |
                    v

            Enterprise Documents

Features

Available MCP Tools

calculator_add / calculator_multiply

Basic arithmetic tools.

search_company_documents

Searches enterprise documents using the RAG pipeline from project 02, called over HTTP. Requires an api_key parameter, validated against MCP_API_KEY.

Example:

Input:

{ "question": "How many days can employees work remotely?", "api_key": "your-mcp-api-key" }

Output:

"Employees can work remotely up to three days per week."

get_employee_leave

Looks up an employee's remaining PTO days from an in-memory store.

Input: {"employee_name": "John"} Output: "John has 12 PTO days remaining."

get_ticket_information

Looks up ticket status, assigned team, and priority from an in-memory store.

Input: {"ticket_id": "INC-1001"} Output: "INC-1001 status: In Progress. Assigned team: Platform Engineering. Priority: High."

Note: Authentication is currently only enforced on search_company_documents. The employee and ticket tools don't yet call authenticate() — see Future Enhancements.

Project Structure

04-mcp-server/

├── server.py
├── auth.py
├── client.py
│
├── tools/
│   ├── calculator.py
│   ├── rag_search.py
│   ├── employee.py
│   └── ticket.py
│
├── database/
│   └── employees.py
│
├── tickets/
│   └── tickets.py
│
├── README.md
│
└── requirements.txt

Technology Stack

• Python 3.11+

• Model Context Protocol (MCP)

• FastMCP

• Python functions exposed as AI tools

Installation

1. Clone repository

git clone <repository-url>

Navigate:

cd 04-mcp-server

2. Create virtual environment

python -m venv venv

Activate:

Mac/Linux:

source venv/bin/activate

3. Install dependencies

pip install -r requirements.txt

Running the MCP Server

Start the server:

python server.py

The MCP server will start and expose available tools.

Example Tool Definition

Example MCP tool:

@mcp.tool()
def calculator_add(a: float, b: float) -> float:

    return a + b

The function becomes discoverable as an MCP tool.

Learning Outcomes

Through this project, I learned:

• How MCP works as a communication layer for AI applications

• How to create custom MCP tools

• How to expose Python functions as AI capabilities

• How AI agents can discover and use external tools

• The difference between traditional function calls and protocol-based tool access

Future Enhancements

Planned improvements:

• Extend authentication to get_employee_leave and get_ticket_information (currently only search_company_documents is protected)

• Replace in-memory employee/ticket data with real data sources

• Add automated tests for tool call handling and auth failures

• Deploy MCP server as a hosted service

• Connect MCP server as a callable tool set for the multi-agent workflow project

Relationship to Previous Projects

This project builds on previous AI engineering concepts:

Project 01 — Basic Tool Use

Agent
 |
 +-- Tools

Project 02 — RAG Agent

Documents
 |
 v
Vector Database
 |
 v
Knowledge Retrieval

Project 03 — Multi-Agent Workflow

Orchestrator
 |
 +-- Research Agent
 +-- Writer Agent

Project 04 — MCP Server

AI System
 |
 v
MCP Protocol
 |
 v
Reusable External Tools

Technologies Used

python, uvicorn, fastmcp, pydantic, typing, mcp