Overview

The itemit MCP Server is a back-end application designed to centralize asset inventory, telemetry, and location data for organizations. It implements the Model Context Protocol (MCP) concepts to make asset metadata, time-series telemetry and location updates available through a consistent API. The server is intended to support multi-tenant use (many organizations) and to integrate with IoT devices, sensors, mobile apps and analytics pipelines.

For developers, the server provides a ready-made platform to record assets, attach monitoring data and expose location updates in a structured way. Deploying the MCP server simplifies building dashboards, alerting rules, integrations and downstream analytics since it standardizes how device/context information is stored and queried.

Features

RESTful API for asset, organization and location management
Telemetry ingestion for time-series sensor data
Location updates and geospatial metadata support
Multi-tenant (organization) separation for inventory and monitoring
Authentication and access control (API keys / tokens)
Docker-friendly deployment and environment configuration
Extensible data model suitable for integration with analytics and GIS tools
Audit logging and basic change history for assets (where enabled)

Installation / Configuration

This section shows typical steps to get the server running locally or in a containerized environment. Adjust commands to match the actual repo structure and runtime (Node/Python/Go) in the project.

Clone the repository:

git clone https://github.com/umin-ai/itemit-mcp.git
cd itemit-mcp

Run with Docker Compose (recommended for development):

# docker-compose.yml (example)
version: '3.8'
services:
  mcp-server:
    build: .
    ports:
      - "8000:8000"
    env_file:
      - .env
    depends_on:
      - db
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: mcp
      POSTGRES_PASSWORD: mcppass
      POSTGRES_DB: mcpdb
    volumes:
      - db-data:/var/lib/postgresql/data

volumes:
  db-data:

Create a .env file with essential configuration (example):

MCP_DB_HOST=db
MCP_DB_PORT=5432
MCP_DB_NAME=mcpdb
MCP_DB_USER=mcp
MCP_DB_PASS=mcppass

MCP_SERVER_PORT=8000
MCP_SECRET_KEY=replace-with-a-secure-secret
MCP_ENABLE_AUTH=true

Start the stack:

docker-compose up --build

If the project uses migrations, run them after database is available:

# Example migration commands
# Replace with actual commands from the project (e.g. alembic, flyway, knex, prisma, etc.)
docker-compose exec mcp-server ./manage.py migrate

Notes:

Replace placeholders in .env with production-ready secrets.
For production, use a managed database and TLS; run behind a reverse proxy.

Available Tools / Resources

GitHub repository: https://github.com/umin-ai/itemit-mcp
API examples (curl) — see examples below
Use a Postman / HTTP client for interactive exploration
If provided in the repo: OpenAPI / Swagger spec can be used to generate clients

Check the repository for any included docs, client libraries or example integrations that match your deployment environment.

Quick API Examples

Below are common workflows for interacting with a typical MCP-style REST API. Exact endpoints may vary in the repository; adapt paths and payloads accordingly.

Create an organization:

curl -X POST http://localhost:8000/api/orgs \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API_TOKEN>" \
  -d '{"name":"Acme Facilities","slug":"acme"}'

Create an asset:

curl -X POST http://localhost:8000/api/assets \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "org_id": "acme",
    "name": "HVAC Unit 12",
    "asset_type": "hvac",
    "metadata": {"model":"X200","installed":"2023-02-01"}
  }'

Send telemetry:

curl -X POST http://localhost:8000/api/assets/<asset_id>/telemetry \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "timestamp": "2026-04-10T10:15:00Z",
    "metrics": {"temp": 22.3, "humidity": 45}
  }'

Update location:

curl -X POST http://localhost:8000/api/assets/<asset_id>/location \
  -H "Authorization: Bearer <API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "timestamp": "2026-04-10T10:15:00Z",
    "lat": 51.5074,
    "lon": -0.1278,
    "accuracy": 5
  }'

Use Cases

Inventory & operational management: Track physical assets across sites, record ownership, maintenance schedules and metadata.
IoT telemetry collection: Centralize time-series sensor data for monitoring, anomaly detection and reporting.
Location tracking: Maintain last-known positions of equipment, vehicles or personnel and integrate with mapping tools.
Multi-organization deployments: Support hundreds of tenants with separate asset catalogs and access controls.
Analytics pipelines: Feed telemetry and location streams into data warehouses, dashboards and alerting systems.

Best Practices

Use secure API tokens and rotate secrets regularly.
Run the server behind TLS and a reverse proxy in production.
Back up the database and use monitoring to detect service degradation.
Tune retention and telemetry aggregation to manage storage and cost for high-volume ingest.

For more detailed operational instructions, reference the repository README and any documentation included with the project.

Itemit MCP Server for Asset Tracking & Monitoring