indyiq-pi-mcp 1.0.0

package/.env.example

@@ -0,0 +1,3 @@
+PI_BASE_URL=https://<your-pi-server>/piwebapi
+PI_USER=<username>
+PI_PASSWORD=<password>

package/README.md

@@ -0,0 +1,88 @@
+# indyiq-pi-mcp
+
+An [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server that exposes OSIsoft PI Web API as read-only tools for Claude. Runs as a local stdio process — no separate server needed. Each user gets their own instance spawned by Claude.
+
+## Installation
+
+```bash
+npm install -g indyiq-pi-mcp
+```
+
+## Connecting to Claude
+
+Credentials are passed via the `env` block in your MCP config.
+
+### Claude Code (`~/.claude/settings.json`)
+
+```json
+{
+  "mcpServers": {
+    "pi": {
+      "type": "stdio",
+      "command": "indyiq-pi-mcp",
+      "env": {
+        "PI_BASE_URL": "https://<your-pi-server>/piwebapi",
+        "PI_USER": "<username>",
+        "PI_PASSWORD": "<password>"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop (`claude_desktop_config.json`)
+
+```json
+{
+  "mcpServers": {
+    "pi": {
+      "command": "indyiq-pi-mcp",
+      "env": {
+        "PI_BASE_URL": "https://<your-pi-server>/piwebapi",
+        "PI_USER": "<username>",
+        "PI_PASSWORD": "<password>"
+      }
+    }
+  }
+}
+```
+
+## Local development
+
+```bash
+git clone https://github.com/indyiq/indyiq-pi-mcp
+cd indyiq-pi-mcp
+npm install
+cp .env.example .env   # fill in credentials
+node server.js
+```
+
+## Available Tools
+
+All tools are **read-only** — no writes to PI Web API.
+
+| Category | Tools |
+|----------|-------|
+| **System** | `piwebapi_home`, `piwebapi_system_status`, `piwebapi_system_versions` |
+| **Cache** | `piwebapi_cache`, `piwebapi_cache_find` |
+| **Servers** | `piwebapi_list_asset_servers`, `piwebapi_list_data_servers` |
+| **Asset Databases** | `piwebapi_list_databases`, `piwebapi_get_database` |
+| **Elements** | `piwebapi_get_element`, `piwebapi_list_elements`, `piwebapi_search_elements` |
+| **Attributes** | `piwebapi_get_element_attributes`, `piwebapi_get_attribute`, `piwebapi_get_attribute_value` |
+| **Templates** | `piwebapi_list_element_templates` |
+| **PI Points** | `piwebapi_get_point`, `piwebapi_list_data_server_points`, `piwebapi_search_points` |
+| **Stream Data** | `piwebapi_get_stream_end`, `piwebapi_get_stream_recorded`, `piwebapi_get_stream_interpolated`, `piwebapi_get_stream_summary`, `piwebapi_get_stream_plot` |
+| **Bulk Stream** | `piwebapi_streamsets_end`, `piwebapi_streamsets_recorded`, `piwebapi_streamsets_interpolated`, `piwebapi_streamsets_summary` |
+| **Event Frames** | `piwebapi_search_event_frames`, `piwebapi_get_event_frame`, `piwebapi_get_event_frame_attributes`, `piwebapi_list_element_event_frames` |
+| **Batch** | `piwebapi_batch` |
+
+## Local Cache
+
+On startup the server builds a SQLite cache (`cache.db`) of servers, databases, elements, attributes, points, and recent event frames (last 30 days). Use the `piwebapi_cache` and `piwebapi_cache_find` tools to inspect it.
+
+## Architecture
+
+| File | Purpose |
+|------|---------|
+| `server.js` | Stdio entry point — connects MCP server to Claude via stdin/stdout |
+| `tools.js` | All 33 MCP tool definitions, PI Web API client, cache, and markdown formatter |

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "indyiq-pi-mcp",
+  "version": "1.0.0",
+  "description": "MCP server exposing OSIsoft PI Web API as read-only tools for Claude",
+  "main": "server.js",
+  "bin": {
+    "indyiq-pi-mcp": "server.js"
+  },
+  "files": [
+    "server.js",
+    "tools.js",
+    ".env.example"
+  ],
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node server.js"
+  },
+  "keywords": [
+    "mcp",
+    "pi",
+    "piwebapi",
+    "osisoft",
+    "claude"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "axios": "^1.7.0",
+    "better-sqlite3": "^12.8.0",
+    "dotenv": "^17.3.1",
+    "zod": "^3.23.0"
+  }
+}

package/server.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+'use strict';
+
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { createMcpServer } = require('./tools.js');
+
+async function main() {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch(err => {
+  process.stderr.write(`Fatal: ${err.message}\n`);
+  process.exit(1);
+});

package/tools.js

@@ -0,0 +1,951 @@
+'use strict';
+
+require('dotenv').config();
+
+const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
+const { z } = require('zod');
+const axios = require('axios');
+const https = require('https');
+
+// ── Config ────────────────────────────────────────────────────────────────────
+const PI_BASE_URL = process.env.PI_BASE_URL;
+const PI_USER = process.env.PI_USER;
+const PI_PASSWORD = process.env.PI_PASSWORD;
+
+// ── HTTP client ───────────────────────────────────────────────────────────────
+const piClient = axios.create({
+  baseURL: PI_BASE_URL,
+  auth: { username: PI_USER, password: PI_PASSWORD },
+  httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+  headers: { Accept: 'application/json' },
+  timeout: 30000,
+});
+
+async function piGet(path, params = {}) {
+  const cleanParams = Object.fromEntries(
+    Object.entries(params).filter(([, v]) => v !== undefined && v !== null && v !== '')
+  );
+  const res = await piClient.get(path, { params: cleanParams });
+  return res.data;
+}
+
+async function piPost(path, body, params = {}) {
+  const cleanParams = Object.fromEntries(
+    Object.entries(params).filter(([, v]) => v !== undefined && v !== null && v !== '')
+  );
+  const res = await piClient.post(path, body, { params: cleanParams });
+  return res.data;
+}
+
+// ── Cache ─────────────────────────────────────────────────────────────────────
+
+const Database = require('better-sqlite3');
+const path = require('path');
+
+const db = new Database(path.join(__dirname, 'cache.db'));
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS data_servers (
+    WebId TEXT PRIMARY KEY, Name TEXT, Path TEXT, IsConnected INTEGER, ServerVersion TEXT, last_seen TEXT
+  );
+  CREATE TABLE IF NOT EXISTS asset_servers (
+    WebId TEXT PRIMARY KEY, Name TEXT, Path TEXT, IsConnected INTEGER, last_seen TEXT
+  );
+  CREATE TABLE IF NOT EXISTS databases (
+    WebId TEXT PRIMARY KEY, Name TEXT, Path TEXT, Description TEXT, ServerName TEXT, last_seen TEXT
+  );
+  CREATE TABLE IF NOT EXISTS points (
+    WebId TEXT PRIMARY KEY, Name TEXT, Path TEXT, PointType TEXT,
+    EngineeringUnits TEXT, Description TEXT, ServerName TEXT, last_seen TEXT
+  );
+  CREATE TABLE IF NOT EXISTS elements (
+    WebId TEXT PRIMARY KEY, Name TEXT, Path TEXT, Description TEXT,
+    TemplateName TEXT, DatabaseName TEXT, ServerName TEXT, last_seen TEXT
+  );
+  CREATE TABLE IF NOT EXISTS attributes (
+    WebId TEXT PRIMARY KEY, Name TEXT, Path TEXT, Description TEXT,
+    Type TEXT, EngineeringUnits TEXT, ElementWebId TEXT, ElementName TEXT,
+    DatabaseName TEXT, ServerName TEXT, last_seen TEXT
+  );
+  CREATE TABLE IF NOT EXISTS event_frames (
+    WebId TEXT PRIMARY KEY, Name TEXT, Path TEXT, Description TEXT,
+    TemplateName TEXT, StartTime TEXT, EndTime TEXT, DatabaseName TEXT, ServerName TEXT, last_seen TEXT
+  );
+  CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+`);
+
+// Add last_seen to existing databases that were created before this column existed
+for (const table of ['data_servers','asset_servers','databases','points','elements','attributes','event_frames']) {
+  try { db.prepare(`ALTER TABLE ${table} ADD COLUMN last_seen TEXT`).run(); } catch {}
+}
+
+const NOW = () => new Date().toISOString();
+
+const upsertDataServer  = db.prepare(`INSERT OR REPLACE INTO data_servers  VALUES (@WebId,@Name,@Path,@IsConnected,@ServerVersion,@last_seen)`);
+const upsertAssetServer = db.prepare(`INSERT OR REPLACE INTO asset_servers VALUES (@WebId,@Name,@Path,@IsConnected,@last_seen)`);
+const upsertDatabase    = db.prepare(`INSERT OR REPLACE INTO databases      VALUES (@WebId,@Name,@Path,@Description,@ServerName,@last_seen)`);
+const upsertPoint       = db.prepare(`INSERT OR REPLACE INTO points         VALUES (@WebId,@Name,@Path,@PointType,@EngineeringUnits,@Description,@ServerName,@last_seen)`);
+const upsertElement     = db.prepare(`INSERT OR REPLACE INTO elements       VALUES (@WebId,@Name,@Path,@Description,@TemplateName,@DatabaseName,@ServerName,@last_seen)`);
+const upsertAttribute   = db.prepare(`INSERT OR REPLACE INTO attributes     VALUES (@WebId,@Name,@Path,@Description,@Type,@EngineeringUnits,@ElementWebId,@ElementName,@DatabaseName,@ServerName,@last_seen)`);
+const upsertEventFrame  = db.prepare(`INSERT OR REPLACE INTO event_frames   VALUES (@WebId,@Name,@Path,@Description,@TemplateName,@StartTime,@EndTime,@DatabaseName,@ServerName,@last_seen)`);
+
+const cache = {
+  updatedAt:    db.prepare(`SELECT value FROM meta WHERE key='updatedAt'`).get()?.value ?? null,
+  dataServers:  db.prepare(`SELECT * FROM data_servers`).all(),
+  assetServers: db.prepare(`SELECT * FROM asset_servers`).all(),
+  databases:    db.prepare(`SELECT * FROM databases`).all(),
+  points:       db.prepare(`SELECT * FROM points`).all(),
+  elements:     db.prepare(`SELECT * FROM elements`).all(),
+  attributes:   db.prepare(`SELECT * FROM attributes`).all(),
+  eventFrames:  db.prepare(`SELECT * FROM event_frames`).all(),
+};
+
+// Fetch all pages of a paginated PI Web API endpoint
+async function piGetAll(urlPath, params = {}, pageSize = 1000) {
+  const items = [];
+  let startIndex = 0;
+  while (true) {
+    const res = await piGet(urlPath, { ...params, maxCount: pageSize, startIndex });
+    const page = res?.Items ?? [];
+    items.push(...page);
+    if (page.length < pageSize) break;
+    startIndex += pageSize;
+  }
+  return items;
+}
+
+// Run async tasks with limited concurrency
+async function withConcurrency(items, concurrency, fn) {
+  const results = [];
+  for (let i = 0; i < items.length; i += concurrency) {
+    const batch = items.slice(i, i + concurrency);
+    const batchResults = await Promise.all(batch.map(fn));
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+async function refreshCache() {
+  try {
+    console.log('[cache] starting refresh...');
+
+    // ── Servers ──
+    const [dsRes, asRes] = await Promise.all([
+      piGet('/dataservers'),
+      piGet('/assetservers'),
+    ]);
+    cache.dataServers  = dsRes?.Items ?? [];
+    cache.assetServers = asRes?.Items ?? [];
+    console.log(`[cache] ${cache.dataServers.length} data servers, ${cache.assetServers.length} AF servers`);
+
+    // ── Databases ──
+    const dbResults = await Promise.all(
+      cache.assetServers.map(s =>
+        piGet(`/assetservers/${encodeURIComponent(s.WebId)}/assetdatabases`)
+          .then(r => (r?.Items ?? []).map(d => ({ ...d, ServerName: s.Name })))
+          .catch(() => [])
+      )
+    );
+    cache.databases = dbResults.flat();
+    console.log(`[cache] ${cache.databases.length} databases`);
+
+    // ── Points ──
+    const ptResults = await Promise.all(
+      cache.dataServers.map(s =>
+        piGetAll(`/dataservers/${encodeURIComponent(s.WebId)}/points`)
+          .then(items => items.map(pt => ({ ...pt, ServerName: s.Name })))
+          .catch(() => [])
+      )
+    );
+    cache.points = ptResults.flat();
+    console.log(`[cache] ${cache.points.length} points`);
+
+    // ── Elements (all descendants, paginated, per database) ──
+    const elResults = await withConcurrency(cache.databases, 3, async (database) => {
+      const items = await piGetAll(
+        `/assetdatabases/${encodeURIComponent(database.WebId)}/elements`,
+        { searchFullHierarchy: true }
+      ).catch(() => []);
+      return items.map(e => ({ ...e, DatabaseName: database.Name, ServerName: database.ServerName }));
+    });
+    cache.elements = elResults.flat();
+    console.log(`[cache] ${cache.elements.length} elements`);
+
+    // ── Attributes (per element, batched 5 at a time) ──
+    console.log(`[cache] fetching attributes for ${cache.elements.length} elements...`);
+    const atResults = await withConcurrency(cache.elements, 5, async (el) => {
+      const items = await piGetAll(
+        `/elements/${encodeURIComponent(el.WebId)}/attributes`,
+        { selectedFields: 'Items.WebId;Items.Name;Items.Path;Items.Description;Items.Type;Items.DefaultUnitsNameAbbreviation' }
+      ).catch(() => []);
+      return items.map(a => ({
+        ...a,
+        EngineeringUnits: a.DefaultUnitsNameAbbreviation ?? null,
+        ElementWebId: el.WebId,
+        ElementName: el.Name,
+        DatabaseName: el.DatabaseName,
+        ServerName: el.ServerName,
+      }));
+    });
+    cache.attributes = atResults.flat();
+    console.log(`[cache] ${cache.attributes.length} attributes`);
+
+    // ── Event Frames (last 30 days, per database, upsert by WebId) ──
+    const efResults = await withConcurrency(cache.databases, 3, async (database) => {
+      const items = await piGetAll(
+        `/assetdatabases/${encodeURIComponent(database.WebId)}/eventframes`,
+        { startTime: '*-30d', selectedFields: 'Items.WebId;Items.Name;Items.Path;Items.Description;Items.TemplateName;Items.StartTime;Items.EndTime' }
+      ).catch(() => []);
+      return items.map(e => ({ ...e, DatabaseName: database.Name, ServerName: database.ServerName }));
+    });
+    cache.eventFrames = efResults.flat();
+    console.log(`[cache] ${cache.eventFrames.length} event frames`);
+
+    cache.updatedAt = new Date().toISOString();
+
+    // ── Persist to SQLite (upsert by WebId — no DELETE, updates in place) ──
+    console.log('[cache] persisting to SQLite...');
+    const now = NOW();
+    const persist = db.transaction(() => {
+      for (const r of cache.dataServers)  upsertDataServer.run({ WebId: r.WebId, Name: r.Name, Path: r.Path, IsConnected: r.IsConnected ? 1 : 0, ServerVersion: r.ServerVersion ?? null, last_seen: now });
+      for (const r of cache.assetServers) upsertAssetServer.run({ WebId: r.WebId, Name: r.Name, Path: r.Path, IsConnected: r.IsConnected ? 1 : 0, last_seen: now });
+      for (const r of cache.databases)    upsertDatabase.run({ WebId: r.WebId, Name: r.Name, Path: r.Path, Description: r.Description ?? null, ServerName: r.ServerName, last_seen: now });
+      for (const r of cache.points)       upsertPoint.run({ WebId: r.WebId, Name: r.Name, Path: r.Path, PointType: r.PointType ?? null, EngineeringUnits: r.EngineeringUnits ?? null, Description: r.Description ?? null, ServerName: r.ServerName, last_seen: now });
+      for (const r of cache.elements)     upsertElement.run({ WebId: r.WebId, Name: r.Name, Path: r.Path, Description: r.Description ?? null, TemplateName: r.TemplateName ?? null, DatabaseName: r.DatabaseName, ServerName: r.ServerName, last_seen: now });
+      for (const r of cache.attributes)   upsertAttribute.run({ WebId: r.WebId, Name: r.Name, Path: r.Path, Description: r.Description ?? null, Type: r.Type ?? null, EngineeringUnits: r.EngineeringUnits ?? null, ElementWebId: r.ElementWebId, ElementName: r.ElementName, DatabaseName: r.DatabaseName, ServerName: r.ServerName, last_seen: now });
+      for (const r of cache.eventFrames)  upsertEventFrame.run({ WebId: r.WebId, Name: r.Name, Path: r.Path ?? null, Description: r.Description ?? null, TemplateName: r.TemplateName ?? null, StartTime: r.StartTime ?? null, EndTime: r.EndTime ?? null, DatabaseName: r.DatabaseName, ServerName: r.ServerName, last_seen: now });
+      db.prepare(`INSERT OR REPLACE INTO meta VALUES ('updatedAt', ?)`).run(cache.updatedAt);
+    });
+    persist();
+
+    console.log(`[cache] done — ${cache.dataServers.length} data servers, ${cache.assetServers.length} AF servers, ${cache.databases.length} databases, ${cache.points.length} points, ${cache.elements.length} elements, ${cache.attributes.length} attributes, ${cache.eventFrames.length} event frames`);
+  } catch (err) {
+    console.error('[cache] refresh error:', err.message);
+  }
+}
+
+function flushStaleData() {
+  const tables = ['data_servers','asset_servers','databases','points','elements','attributes','event_frames'];
+  const result = db.transaction(() => {
+    let total = 0;
+    for (const table of tables) {
+      const { changes } = db.prepare(
+        `DELETE FROM ${table} WHERE last_seen < datetime('now', '-20 days')`
+      ).run();
+      total += changes;
+    }
+    return total;
+  })();
+  if (result > 0) console.log(`[cache] flushed ${result} stale rows (older than 20 days)`);
+}
+
+// Refresh immediately on startup, then every 2 minutes
+refreshCache();
+setInterval(refreshCache, 2 * 60 * 1000);
+
+// Flush stale data on startup and once per day
+flushStaleData();
+setInterval(flushStaleData, 24 * 60 * 60 * 1000);
+
+// ── SQLite cache queries ──────────────────────────────────────────────────────
+
+const sql = {
+  assetServers:  db.prepare(`SELECT * FROM asset_servers`),
+  dataServers:   db.prepare(`SELECT * FROM data_servers`),
+  dbsByServer:   db.prepare(`SELECT * FROM databases WHERE ServerName = ?`),
+  dbByWebId:     db.prepare(`SELECT * FROM databases WHERE WebId = ?`),
+  dbByPath:      db.prepare(`SELECT * FROM databases WHERE Path = ?`),
+  elementByWebId:  db.prepare(`SELECT * FROM elements WHERE WebId = ?`),
+  elementByPath:   db.prepare(`SELECT * FROM elements WHERE Path = ?`),
+  elementsByDb:    db.prepare(`SELECT * FROM elements WHERE DatabaseName = ?`),
+  elementsByParentPath: db.prepare(`SELECT * FROM elements WHERE Path LIKE ? AND Path NOT LIKE ?`),
+  attrByWebId:     db.prepare(`SELECT * FROM attributes WHERE WebId = ?`),
+  attrsByElement:  db.prepare(`SELECT * FROM attributes WHERE ElementWebId = ?`),
+  pointByWebId:    db.prepare(`SELECT * FROM points WHERE WebId = ?`),
+  pointByPath:     db.prepare(`SELECT * FROM points WHERE Path = ?`),
+  pointsByServer:  db.prepare(`SELECT * FROM points WHERE ServerName = ?`),
+  hasRows: (table) => db.prepare(`SELECT 1 FROM ${table} LIMIT 1`).get(),
+};
+
+// ── Output formatter ─────────────────────────────────────────────────────────
+
+function respond(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+
+function respondCached(data) {
+  const note = `\n\n// cache last updated: ${cache.updatedAt ?? 'unknown'}`;
+  return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) + note }] };
+}
+
+// ── MCP Server factory ────────────────────────────────────────────────────────
+function createMcpServer() {
+  const server = new McpServer({
+    name: 'piwebapi-mcp',
+    version: '1.0.0',
+  });
+
+  server.tool(
+    'piwebapi_home',
+    'Get the PI Web API root landing page with links to all top-level resources (asset servers, data servers, system info, etc.)',
+    {},
+    async () => {
+      const data = await piGet('/');
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_cache',
+    'Return a summary of the cached PI Web API inventory: servers, databases, and point count with their WebIds. Refreshed every 2 minutes.',
+    {},
+    async () => {
+      const summary = {
+        updatedAt:      cache.updatedAt,
+        dataServers:    cache.dataServers.map(r => ({ Name: r.Name, WebId: r.WebId, Path: r.Path })),
+        assetServers:   cache.assetServers.map(r => ({ Name: r.Name, WebId: r.WebId, Path: r.Path })),
+        databases:      cache.databases.map(r => ({ Name: r.Name, WebId: r.WebId, ServerName: r.ServerName })),
+        pointCount:      cache.points.length,
+        elementCount:    cache.elements.length,
+        attributeCount:  cache.attributes.length,
+        eventFrameCount: cache.eventFrames.length,
+      };
+      return respondCached(summary);
+    }
+  );
+
+  server.tool(
+    'piwebapi_cache_find',
+    'Search the cached inventory by name. Returns matching Name, WebId, Path. Use this to look up WebIds before making API calls.',
+    {
+      name: z.string().describe('Name or partial name to search (case-insensitive)'),
+      type: z.enum(['points', 'elements', 'attributes', 'databases', 'eventframes', 'all']).optional().describe('What to search (default: all)'),
+    },
+    async ({ name, type = 'all' }) => {
+      const pattern = name.toLowerCase();
+      const match = item => item.Name?.toLowerCase().includes(pattern);
+      const results = {};
+      if (type === 'points'      || type === 'all') results.points      = cache.points.filter(match).map(r => ({ Name: r.Name, WebId: r.WebId, Path: r.Path, PointType: r.PointType, ServerName: r.ServerName }));
+      if (type === 'elements'    || type === 'all') results.elements    = cache.elements.filter(match).map(r => ({ Name: r.Name, WebId: r.WebId, Path: r.Path, TemplateName: r.TemplateName, DatabaseName: r.DatabaseName }));
+      if (type === 'attributes'  || type === 'all') results.attributes  = cache.attributes.filter(match).map(r => ({ Name: r.Name, WebId: r.WebId, Type: r.Type, ElementName: r.ElementName, DatabaseName: r.DatabaseName }));
+      if (type === 'databases'   || type === 'all') results.databases   = cache.databases.filter(match).map(r => ({ Name: r.Name, WebId: r.WebId, ServerName: r.ServerName }));
+      if (type === 'eventframes' || type === 'all') results.eventFrames = cache.eventFrames.filter(match).map(r => ({ Name: r.Name, WebId: r.WebId, StartTime: r.StartTime, EndTime: r.EndTime, TemplateName: r.TemplateName, DatabaseName: r.DatabaseName }));
+      return respondCached(results);
+    }
+  );
+
+  server.tool(
+    'piwebapi_list_asset_servers',
+    'List all AF servers. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ selectedFields }) => {
+      if (sql.hasRows('asset_servers')) return respondCached(sql.assetServers.all());
+      const data = await piGet('/assetservers', { selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_list_data_servers',
+    'List all PI Data Archive servers. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ selectedFields }) => {
+      if (sql.hasRows('data_servers')) return respondCached(sql.dataServers.all());
+      const data = await piGet('/dataservers', { selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_list_databases',
+    'List AF databases on a server. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      serverWebId: z.string().describe('WebId of the AF server'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ serverWebId, selectedFields }) => {
+      if (sql.hasRows('databases')) {
+        const server = db.prepare(`SELECT Name FROM asset_servers WHERE WebId = ?`).get(serverWebId);
+        if (server) return respondCached(sql.dbsByServer.all(server.Name));
+      }
+      const data = await piGet(`/assetservers/${encodeURIComponent(serverWebId)}/assetdatabases`, { selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_element',
+    'Get an AF Element by WebId or path. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      path: z.string().optional().describe('Full AF path, e.g. "\\\\AFServer\\MyDB\\Equipment\\Pump1"'),
+      webId: z.string().optional().describe('WebId of the element'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ path, webId, selectedFields }) => {
+      if (!path && !webId) throw new Error('Provide either path or webId');
+      if (sql.hasRows('elements')) {
+        const row = webId ? sql.elementByWebId.get(webId) : sql.elementByPath.get(path);
+        if (row) return respondCached(row);
+      }
+      const data = webId
+        ? await piGet(`/elements/${encodeURIComponent(webId)}`, { selectedFields })
+        : await piGet('/elements', { path, selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_list_elements',
+    'List elements. Omit parentWebId to list ALL cached elements. With parentWebId, lists children of that database or element. Always served from cache when available.',
+    {
+      parentWebId: z.string().optional().describe('WebId of parent AF Database or Element. Omit to return all elements from cache.'),
+      parentType: z.enum(['database', 'element']).optional().describe('Whether the parent is a "database" or "element" (required when parentWebId is provided)'),
+      nameFilter: z.string().optional().describe('Name filter with wildcards, e.g. "Pump*"'),
+      templateName: z.string().optional().describe('Only return elements based on this template'),
+      maxCount: z.number().int().optional().describe('Maximum number of results (default 1000)'),
+      startIndex: z.number().int().optional().describe('Pagination start index'),
+      searchFullHierarchy: z.boolean().optional().describe('Search all descendants, not just immediate children'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ parentWebId, parentType, nameFilter, templateName, maxCount, startIndex, searchFullHierarchy, selectedFields }) => {
+      if (sql.hasRows('elements')) {
+        let rows;
+        if (!parentWebId) {
+          // No filter — return entire cache
+          rows = db.prepare(`SELECT * FROM elements`).all();
+        } else if (parentType === 'database') {
+          const dbRow = sql.dbByWebId.get(parentWebId);
+          if (dbRow) {
+            rows = sql.elementsByDb.all(dbRow.Name);
+            if (!searchFullHierarchy) {
+              const depth = dbRow.Path.split('\\').filter(Boolean).length + 1;
+              rows = rows.filter(r => r.Path.split('\\').filter(Boolean).length === depth);
+            }
+          }
+        } else {
+          const parent = sql.elementByWebId.get(parentWebId);
+          if (parent) {
+            const prefix = parent.Path + '\\';
+            rows = searchFullHierarchy
+              ? db.prepare(`SELECT * FROM elements WHERE Path LIKE ?`).all(prefix + '%')
+              : db.prepare(`SELECT * FROM elements WHERE Path LIKE ? AND Path NOT LIKE ?`).all(prefix + '%', prefix + '%\\%');
+          }
+        }
+        if (rows) {
+          if (nameFilter) { const pat = nameFilter.replace(/\*/g, '').toLowerCase(); rows = rows.filter(r => r.Name.toLowerCase().includes(pat)); }
+          if (templateName) rows = rows.filter(r => r.TemplateName === templateName);
+          const start = startIndex ?? 0;
+          return respondCached(rows.slice(start, start + (maxCount ?? 1000)));
+        }
+      }
+      if (!parentWebId) throw new Error('Cache is empty — provide parentWebId to query PI Web API directly');
+      const base = parentType === 'database'
+        ? `/assetdatabases/${encodeURIComponent(parentWebId)}/elements`
+        : `/elements/${encodeURIComponent(parentWebId)}/elements`;
+      const data = await piGet(base, { nameFilter, templateName, maxCount, startIndex, searchFullHierarchy, selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_search_elements',
+    'Search AF Elements by name/template. Searches cache first, falls back to PI Web API for advanced query syntax.',
+    {
+      query: z.string().describe('Search query, e.g. "name:Pump*" or "name:Compressor* template:RotatingEquipment"'),
+      databaseWebId: z.string().optional().describe('Restrict search to a specific AF Database by its WebId'),
+      maxCount: z.number().int().optional().describe('Maximum results to return (default 1000)'),
+      startIndex: z.number().int().optional().describe('Pagination start index'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ query, databaseWebId, maxCount, startIndex, selectedFields }) => {
+      if (sql.hasRows('elements')) {
+        const nameMatch = query.match(/name:(\S+)/i);
+        const templateMatch = query.match(/template:(\S+)/i);
+        if (nameMatch || templateMatch) {
+          let rows = databaseWebId
+            ? (() => { const d = sql.dbByWebId.get(databaseWebId); return d ? sql.elementsByDb.all(d.Name) : []; })()
+            : db.prepare(`SELECT * FROM elements`).all();
+          if (nameMatch) {
+            const pat = nameMatch[1].replace(/\*/g, '').toLowerCase();
+            rows = rows.filter(r => r.Name.toLowerCase().includes(pat));
+          }
+          if (templateMatch) {
+            const pat = templateMatch[1].replace(/\*/g, '').toLowerCase();
+            rows = rows.filter(r => r.TemplateName?.toLowerCase().includes(pat));
+          }
+          const start = startIndex ?? 0;
+          return respondCached(rows.slice(start, start + (maxCount ?? 1000)));
+        }
+      }
+      const data = await piGet('/elements/search', { query, databaseWebId, maxCount, startIndex, selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_element_attributes',
+    'Get attributes of an AF Element. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      elementWebId: z.string().describe('WebId of the AF Element'),
+      nameFilter: z.string().optional().describe('Filter by attribute name with wildcards'),
+      categoryName: z.string().optional().describe('Filter by attribute category'),
+      templateName: z.string().optional().describe('Filter by template name'),
+      valueType: z.string().optional().describe('Filter by value type, e.g. "Double", "String"'),
+      searchFullHierarchy: z.boolean().optional().describe('Include attributes from child elements'),
+      maxCount: z.number().int().optional().describe('Maximum results (default 1000)'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ elementWebId, nameFilter, categoryName, templateName, valueType, searchFullHierarchy, maxCount, selectedFields }) => {
+      if (sql.hasRows('attributes')) {
+        let rows = sql.attrsByElement.all(elementWebId);
+        if (nameFilter) { const pat = nameFilter.replace(/\*/g, '').toLowerCase(); rows = rows.filter(r => r.Name.toLowerCase().includes(pat)); }
+        if (valueType)  rows = rows.filter(r => r.Type === valueType);
+        return respondCached(rows.slice(0, maxCount ?? 1000));
+      }
+      const data = await piGet(`/elements/${encodeURIComponent(elementWebId)}/attributes`, {
+        nameFilter, categoryName, templateName, valueType, searchFullHierarchy, maxCount, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_attribute_value',
+    'Get the current value of an AF Attribute by its WebId.',
+    {
+      attributeWebId: z.string().describe('WebId of the AF Attribute'),
+    },
+    async ({ attributeWebId }) => {
+      const data = await piGet(`/attributes/${encodeURIComponent(attributeWebId)}/value`);
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_stream_end',
+    'Get the latest/most recent value for a PI tag or AF Attribute stream by WebId.',
+    {
+      webId: z.string().describe('WebId of the PI Point or AF Attribute'),
+      desiredUnits: z.string().optional().describe('Desired engineering units for the returned value'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ webId, desiredUnits, selectedFields }) => {
+      const data = await piGet(`/streams/${encodeURIComponent(webId)}/end`, { desiredUnits, selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_stream_recorded',
+    'Get recorded (raw) historical values from a PI tag or AF Attribute stream over a time range.',
+    {
+      webId: z.string().describe('WebId of the PI Point or AF Attribute'),
+      startTime: z.string().optional().describe('Start time, e.g. "*-1d", "2024-01-01T00:00:00Z", or PI time expressions like "y" (yesterday)'),
+      endTime: z.string().optional().describe('End time, e.g. "*" (now), "2024-01-02T00:00:00Z"'),
+      maxCount: z.number().int().optional().describe('Maximum number of values to return (default 1000)'),
+      boundaryType: z.enum(['Inside', 'Outside', 'Interpolated', 'ExactOrBefore', 'ExactOrAfter']).optional().describe('Boundary retrieval type'),
+      filterExpression: z.string().optional().describe('PI performance equation filter'),
+      desiredUnits: z.string().optional().describe('Desired engineering units'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ webId, startTime, endTime, maxCount, boundaryType, filterExpression, desiredUnits, selectedFields }) => {
+      const data = await piGet(`/streams/${encodeURIComponent(webId)}/recorded`, {
+        startTime, endTime, maxCount, boundaryType, filterExpression, desiredUnits, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_stream_interpolated',
+    'Get interpolated values at regular intervals from a PI tag or AF Attribute stream.',
+    {
+      webId: z.string().describe('WebId of the PI Point or AF Attribute'),
+      startTime: z.string().optional().describe('Start time, e.g. "*-1d" or "2024-01-01T00:00:00Z"'),
+      endTime: z.string().optional().describe('End time, e.g. "*" (now)'),
+      interval: z.string().optional().describe('Time interval between values, e.g. "1h", "15m", "1d"'),
+      desiredUnits: z.string().optional().describe('Desired engineering units'),
+      filterExpression: z.string().optional().describe('PI performance equation filter'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ webId, startTime, endTime, interval, desiredUnits, filterExpression, selectedFields }) => {
+      const data = await piGet(`/streams/${encodeURIComponent(webId)}/interpolated`, {
+        startTime, endTime, interval, desiredUnits, filterExpression, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_stream_summary',
+    'Get statistical summary (min, max, average, std dev, count, etc.) for a PI tag or AF Attribute over a time range.',
+    {
+      webId: z.string().describe('WebId of the PI Point or AF Attribute'),
+      startTime: z.string().optional().describe('Start time, e.g. "*-1d" or "2024-01-01T00:00:00Z"'),
+      endTime: z.string().optional().describe('End time, e.g. "*" (now)'),
+      summaryType: z.string().optional().describe('Comma or pipe separated summary types: Average, Maximum, Minimum, StdDev, Total, Count, PercentGood, etc. Default: All'),
+      calculationBasis: z.enum(['TimeWeighted', 'EventWeighted', 'TimeWeightedContinuous', 'TimeWeightedDiscrete', 'EventWeightedExcludeMostRecentEvent', 'EventWeightedExcludeEarliestEvent', 'EventWeightedIncludeBothEnds']).optional().describe('Basis for calculation'),
+      filterExpression: z.string().optional().describe('PI performance equation filter'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ webId, startTime, endTime, summaryType, calculationBasis, filterExpression, selectedFields }) => {
+      const data = await piGet(`/streams/${encodeURIComponent(webId)}/summary`, {
+        startTime, endTime, summaryType, calculationBasis, filterExpression, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_stream_plot',
+    'Get plot (chart-optimized) values for a PI tag or AF Attribute. Returns min/max pairs per interval, ideal for trending/visualization.',
+    {
+      webId: z.string().describe('WebId of the PI Point or AF Attribute'),
+      startTime: z.string().optional().describe('Start time, e.g. "*-1d"'),
+      endTime: z.string().optional().describe('End time, e.g. "*"'),
+      intervals: z.number().int().optional().describe('Number of intervals for plot (default 24)'),
+      desiredUnits: z.string().optional().describe('Desired engineering units'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ webId, startTime, endTime, intervals, desiredUnits, selectedFields }) => {
+      const data = await piGet(`/streams/${encodeURIComponent(webId)}/plot`, {
+        startTime, endTime, intervals, desiredUnits, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_point',
+    'Get a PI Point by WebId or path. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      path: z.string().optional().describe('Full path to the PI tag, e.g. "\\\\PISERVER\\CDT158"'),
+      webId: z.string().optional().describe('WebId of the PI Point (alternative to path)'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ path, webId, selectedFields }) => {
+      if (!path && !webId) throw new Error('Provide either path or webId');
+      if (sql.hasRows('points')) {
+        const row = webId ? sql.pointByWebId.get(webId) : sql.pointByPath.get(path);
+        if (row) return respondCached(row);
+      }
+      const data = webId
+        ? await piGet(`/points/${encodeURIComponent(webId)}`, { selectedFields })
+        : await piGet('/points', { path, selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_list_data_server_points',
+    'List or search PI Points on a data server. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      serverWebId: z.string().describe('WebId of the PI Data Archive server'),
+      nameFilter: z.string().optional().describe('Tag name filter with wildcards, e.g. "SIN*" or "*Flow*"'),
+      maxCount: z.number().int().optional().describe('Maximum number of results (default 1000)'),
+      startIndex: z.number().int().optional().describe('Pagination start index'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ serverWebId, nameFilter, maxCount, startIndex, selectedFields }) => {
+      if (sql.hasRows('points')) {
+        const srv = db.prepare(`SELECT Name FROM data_servers WHERE WebId = ?`).get(serverWebId);
+        if (srv) {
+          let rows = sql.pointsByServer.all(srv.Name);
+          if (nameFilter) { const pat = nameFilter.replace(/\*/g, '').toLowerCase(); rows = rows.filter(r => r.Name.toLowerCase().includes(pat)); }
+          const start = startIndex ?? 0;
+          return respondCached(rows.slice(start, start + (maxCount ?? 1000)));
+        }
+      }
+      const data = await piGet(`/dataservers/${encodeURIComponent(serverWebId)}/points`, {
+        nameFilter, maxCount, startIndex, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_search_points',
+    'Search PI Points (tags) by name across all cached data servers. Searches cache first, falls back to PI Web API.',
+    {
+      query: z.string().describe('Name or partial name to search, wildcards supported e.g. "Sin*" or "*Flow*"'),
+      serverWebId: z.string().optional().describe('Restrict search to a specific PI Data Archive server by WebId'),
+      maxCount: z.number().int().optional().describe('Maximum results to return (default 1000)'),
+      startIndex: z.number().int().optional().describe('Pagination start index'),
+    },
+    async ({ query, serverWebId, maxCount, startIndex }) => {
+      if (sql.hasRows('points')) {
+        let rows = serverWebId
+          ? (() => { const s = db.prepare(`SELECT Name FROM data_servers WHERE WebId = ?`).get(serverWebId); return s ? sql.pointsByServer.all(s.Name) : []; })()
+          : db.prepare(`SELECT * FROM points`).all();
+        const pat = query.replace(/\*/g, '').toLowerCase();
+        rows = rows.filter(r => r.Name.toLowerCase().includes(pat));
+        const start = startIndex ?? 0;
+        return respondCached(rows.slice(start, start + (maxCount ?? 1000)));
+      }
+      // Fallback: search via each data server
+      const servers = serverWebId
+        ? [{ WebId: serverWebId }]
+        : (await piGet('/dataservers'))?.Items ?? [];
+      const results = await Promise.all(
+        servers.map(s =>
+          piGet(`/dataservers/${encodeURIComponent(s.WebId)}/points`, { nameFilter: query, maxCount, startIndex })
+            .then(r => r?.Items ?? [])
+            .catch(() => [])
+        )
+      );
+      return respond(results.flat());
+    }
+  );
+
+  server.tool(
+    'piwebapi_search_event_frames',
+    'Search for Event Frames in AF using a query string.',
+    {
+      query: z.string().describe('Search query, e.g. "name:Alarm* template:HighTemp"'),
+      databaseWebId: z.string().optional().describe('Restrict search to a specific AF Database by its WebId'),
+      maxCount: z.number().int().optional().describe('Maximum results to return'),
+      startIndex: z.number().int().optional().describe('Pagination start index'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ query, databaseWebId, maxCount, startIndex, selectedFields }) => {
+      const data = await piGet('/eventframes/search', { query, databaseWebId, maxCount, startIndex, selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_event_frame',
+    'Get details of a specific Event Frame by its WebId.',
+    {
+      webId: z.string().describe('WebId of the Event Frame'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ webId, selectedFields }) => {
+      const data = await piGet(`/eventframes/${encodeURIComponent(webId)}`, { selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_system_status',
+    'Get the current status and health of the PI Web API server.',
+    {},
+    async () => {
+      const data = await piGet('/system/status');
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_system_versions',
+    'Get version information for all PI components connected to this PI Web API instance.',
+    {},
+    async () => {
+      const data = await piGet('/system/versions');
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_batch',
+    'Execute multiple PI Web API requests in a single HTTP call for efficiency. Each request can reference results of previous requests using "{N.Content.Field}" syntax.',
+    {
+      requests: z.record(z.object({
+        Method: z.string().describe('HTTP method: GET, POST, PUT, DELETE'),
+        Resource: z.string().describe('Relative URL, e.g. "/piwebapi/streams/{webId}/end"'),
+        Headers: z.record(z.string()).optional().describe('Optional HTTP headers'),
+        Content: z.any().optional().describe('Request body for POST/PUT'),
+        Parameters: z.array(z.string()).optional().describe('References to prior request results'),
+        ParentIds: z.array(z.string()).optional().describe('IDs of requests that must complete first'),
+      })).describe('Object where keys are request IDs and values are request objects'),
+    },
+    async ({ requests }) => {
+      const data = await piPost('/batch', requests);
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_database',
+    'Get an AF Asset Database by WebId or path. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      webId: z.string().optional().describe('WebId of the database'),
+      path: z.string().optional().describe('Full path, e.g. "\\\\AFServer\\MyDB"'),
+      selectedFields: z.string().optional().describe('Semicolon-separated fields to return'),
+    },
+    async ({ webId, path, selectedFields }) => {
+      if (!webId && !path) throw new Error('Provide either webId or path');
+      if (sql.hasRows('databases')) {
+        const row = webId ? sql.dbByWebId.get(webId) : sql.dbByPath.get(path);
+        if (row) return respondCached(row);
+      }
+      const data = webId
+        ? await piGet(`/assetdatabases/${encodeURIComponent(webId)}`, { selectedFields })
+        : await piGet('/assetdatabases', { path, selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_attribute',
+    'Get an AF Attribute by WebId. Returns from cache if available, otherwise queries PI Web API.',
+    {
+      webId: z.string().describe('WebId of the AF Attribute'),
+      selectedFields: z.string().optional().describe('Semicolon-separated fields to return'),
+    },
+    async ({ webId, selectedFields }) => {
+      if (sql.hasRows('attributes')) {
+        const row = sql.attrByWebId.get(webId);
+        if (row) return respondCached(row);
+      }
+      const data = await piGet(`/attributes/${encodeURIComponent(webId)}`, { selectedFields });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_list_element_templates',
+    'List Element Templates defined in an AF Database.',
+    {
+      databaseWebId: z.string().describe('WebId of the AF Database'),
+      nameFilter: z.string().optional().describe('Filter by template name with wildcards'),
+      maxCount: z.number().int().optional().describe('Maximum results (default 1000)'),
+      selectedFields: z.string().optional().describe('Semicolon-separated fields to return'),
+    },
+    async ({ databaseWebId, nameFilter, maxCount, selectedFields }) => {
+      const data = await piGet(`/assetdatabases/${encodeURIComponent(databaseWebId)}/elementtemplates`, {
+        nameFilter, maxCount, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_list_element_event_frames',
+    'List Event Frames associated with a specific AF Element.',
+    {
+      elementWebId: z.string().describe('WebId of the AF Element'),
+      startTime: z.string().optional().describe('Start time filter, e.g. "*-7d"'),
+      endTime: z.string().optional().describe('End time filter, e.g. "*"'),
+      nameFilter: z.string().optional().describe('Event frame name filter with wildcards'),
+      templateName: z.string().optional().describe('Filter by event frame template name'),
+      maxCount: z.number().int().optional().describe('Maximum results'),
+      selectedFields: z.string().optional().describe('Semicolon-separated fields to return'),
+    },
+    async ({ elementWebId, startTime, endTime, nameFilter, templateName, maxCount, selectedFields }) => {
+      const data = await piGet(`/elements/${encodeURIComponent(elementWebId)}/eventframes`, {
+        startTime, endTime, nameFilter, templateName, maxCount, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_get_event_frame_attributes',
+    'Get attributes of an Event Frame by the event frame\'s WebId.',
+    {
+      eventFrameWebId: z.string().describe('WebId of the Event Frame'),
+      nameFilter: z.string().optional().describe('Filter by attribute name with wildcards'),
+      maxCount: z.number().int().optional().describe('Maximum results'),
+      selectedFields: z.string().optional().describe('Semicolon-separated fields to return'),
+    },
+    async ({ eventFrameWebId, nameFilter, maxCount, selectedFields }) => {
+      const data = await piGet(`/eventframes/${encodeURIComponent(eventFrameWebId)}/attributes`, {
+        nameFilter, maxCount, selectedFields,
+      });
+      return respond(data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_streamsets_recorded',
+    'Get recorded (raw) historical values for multiple PI tags or AF Attributes in a single request.',
+    {
+      webId: z.array(z.string()).describe('Array of WebIds'),
+      startTime: z.string().optional().describe('Start time, e.g. "*-1d"'),
+      endTime: z.string().optional().describe('End time, e.g. "*"'),
+      maxCount: z.number().int().optional().describe('Maximum values per stream'),
+      selectedFields: z.string().optional().describe('Semicolon-separated fields to return'),
+    },
+    async ({ webId, startTime, endTime, maxCount, selectedFields }) => {
+      const params = new URLSearchParams();
+      webId.forEach(id => params.append('webId', id));
+      if (startTime) params.append('startTime', startTime);
+      if (endTime) params.append('endTime', endTime);
+      if (maxCount) params.append('maxCount', maxCount);
+      if (selectedFields) params.append('selectedFields', selectedFields);
+      const res = await piClient.get('/streamsets/recorded', { params });
+      return respond(res.data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_streamsets_interpolated',
+    'Get interpolated values at regular intervals for multiple PI tags or AF Attributes.',
+    {
+      webId: z.array(z.string()).describe('Array of WebIds'),
+      startTime: z.string().optional().describe('Start time, e.g. "*-1d"'),
+      endTime: z.string().optional().describe('End time, e.g. "*"'),
+      interval: z.string().optional().describe('Interval between values, e.g. "1h", "15m"'),
+      selectedFields: z.string().optional().describe('Semicolon-separated fields to return'),
+    },
+    async ({ webId, startTime, endTime, interval, selectedFields }) => {
+      const params = new URLSearchParams();
+      webId.forEach(id => params.append('webId', id));
+      if (startTime) params.append('startTime', startTime);
+      if (endTime) params.append('endTime', endTime);
+      if (interval) params.append('interval', interval);
+      if (selectedFields) params.append('selectedFields', selectedFields);
+      const res = await piClient.get('/streamsets/interpolated', { params });
+      return respond(res.data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_streamsets_summary',
+    'Get statistical summaries for multiple PI tags or AF Attributes in a single request.',
+    {
+      webId: z.array(z.string()).describe('Array of WebIds'),
+      startTime: z.string().optional().describe('Start time, e.g. "*-1d"'),
+      endTime: z.string().optional().describe('End time, e.g. "*"'),
+      summaryType: z.string().optional().describe('Summary types: Average, Maximum, Minimum, StdDev, Total, Count, etc.'),
+      calculationBasis: z.enum(['TimeWeighted', 'EventWeighted']).optional().describe('Calculation basis'),
+      selectedFields: z.string().optional().describe('Semicolon-separated fields to return'),
+    },
+    async ({ webId, startTime, endTime, summaryType, calculationBasis, selectedFields }) => {
+      const params = new URLSearchParams();
+      webId.forEach(id => params.append('webId', id));
+      if (startTime) params.append('startTime', startTime);
+      if (endTime) params.append('endTime', endTime);
+      if (summaryType) params.append('summaryType', summaryType);
+      if (calculationBasis) params.append('calculationBasis', calculationBasis);
+      if (selectedFields) params.append('selectedFields', selectedFields);
+      const res = await piClient.get('/streamsets/summary', { params });
+      return respond(res.data);
+    }
+  );
+
+  server.tool(
+    'piwebapi_streamsets_end',
+    'Get the latest values for multiple PI tags or AF Attributes in a single request.',
+    {
+      webId: z.array(z.string()).describe('Array of WebIds for PI Points or AF Attributes'),
+      selectedFields: z.string().optional().describe('Semicolon-separated list of fields to return'),
+    },
+    async ({ webId, selectedFields }) => {
+      const params = new URLSearchParams();
+      webId.forEach(id => params.append('webId', id));
+      if (selectedFields) params.append('selectedFields', selectedFields);
+      const res = await piClient.get('/streamsets/end', { params });
+      return respond(res.data);
+    }
+  );
+
+  return server;
+}
+
+module.exports = { createMcpServer };