Equipment Health MCP Server

An AI agent system that monitors manufacturing equipment health using the Model Context Protocol (MCP). An LLM agent answers natural language questions about equipment by calling tools exposed through an MCP server — backed by real PostgreSQL data, RAG over equipment manuals, and a live observability dashboard.

Architecture

User Question
↓
AI Agent (LLaMA 3.3 70B via Groq)
↓
MCP Client
↓
MCP Server (Python MCP SDK)
↓
5 Tools
↓
PostgreSQL + ChromaDB
↓
Observability Layer → Streamlit Dashboard

Related MCP server: OEE Enterprise Agent

Example agent conversations

Ask: Is equipment E004 showing any anomalies right now? → Yes, E004 (Lathe Machine D) has a temperature reading of 89.72C which exceeds the threshold of 80.0C. Anomaly detected.

Ask: Is E007 overdue for maintenance? → Yes, Compressor G has not been serviced in 90 days. Last event was a bearing replacement — vibration issue unresolved.

Ask: Which equipment has the highest average temperature this week? → E004 has the highest average temperature at 91.2C, significantly above the 80C safety threshold.

Ask: Flag an anomaly for E004 temperature reading of 91.5 → Anomaly successfully flagged for E004: temperature = 91.5 (threshold: 80.0)

5 MCP Tools

Tech Stack

Project Structure

equipment-health-mcp/
├── server/
│   ├── main.py           # MCP server — registers and routes all 5 tools
│   ├── tools.py          # Tool implementations — all database queries
│   ├── database.py       # SQLAlchemy models and session management
│   ├── observability.py  # Logs every tool call to JSONL
│   └── api.py            # FastAPI REST layer on top of MCP tools
├── agent/
│   └── agent.py          # LLM agent that connects to MCP server
├── data/
│   ├── seed.py           # Populates 10 machines with 30 days of sensor data
│   ├── index_manuals.py  # Indexes manual text files into ChromaDB for RAG
│   └── manuals/          # Equipment manual text files for RAG
├── dashboard/
│   └── app.py            # Streamlit observability dashboard
├── tests/
│   └── test_tools.py     # Unit tests for all 5 tools
├── logs/
│   └── tool_calls.jsonl  # Auto-generated observability log
├── .github/
│   └── workflows/
│       └── ci.yml        # GitHub Actions CI pipeline
├── Dockerfile
├── docker-compose.yml
└── requirements.txt

Quick Start

1. Clone and install

git clone https://github.com/AankitPaudel/Equipment-Health-MCP
cd Equipment-Health-MCP
pip install -r requirements.txt

2. Configure environment

cp .env.example .env

Edit .env and add your Groq API key:

GROQ_API_KEY=your_groq_key_here
DATABASE_URL=postgresql://postgres:password@localhost:5432/equipment_db

3. Start the database and seed data

docker-compose up postgres -d
python -c "from server.database import init_db; init_db()"
python data/seed.py

4. Index the equipment manuals for RAG

python data/index_manuals.py

This creates the equipment_manuals ChromaDB collection used by the query_knowledge_base MCP tool.

5. Run the AI agent

python agent/agent.py

6. Run the REST API

uvicorn server.api:app --reload
# Swagger UI available at http://localhost:8000/docs

7. Run the observability dashboard

streamlit run dashboard/app.py
# Dashboard available at http://localhost:8501

8. Run with Docker Compose

docker-compose up

REST API Endpoints

RAG Knowledge Base

The knowledge base is populated from .txt manuals in data/manuals/. Run the indexer after adding or editing manuals:

python data/index_manuals.py

The script chunks the manuals and stores them in the local chroma_db/ directory. Tool 5, query_knowledge_base, searches that collection for manual-backed maintenance guidance.

Observability

Every tool call is logged automatically to logs/tool_calls.jsonl with:

• Timestamp

• Tool name

• Input arguments

• Response time in milliseconds

• Success or failure status

• Error message if failed

The Streamlit dashboard reads this log and displays live metrics including total calls, success rate, average response time, and a bar chart of calls per tool.

CI/CD

GitHub Actions runs on every push to main:

• Spins up a real PostgreSQL instance

• Installs all dependencies

• Seeds the database

• Runs all unit tests with pytest

Running Tests

python -m pytest tests/ -v

Why This Project

Many semiconductor manufacturers are implementing MCP to connect AI agents to production data, quality control systems, and maintenance records. This project demonstrates that architecture at a personal scale — showing how MCP enables AI agents to answer real operational questions using live manufacturing data without custom one-off integrations.