1mkdir project-metrics-mcp
2cd project-metrics-mcp
3npm init -y
4npm install @modelcontextprotocol/sdk zod
5npm install -D typescript @types/node

1{
2  "compilerOptions": {
3    "target": "ES2022",
4    "module": "Node16",
5    "moduleResolution": "Node16",
6    "outDir": "./build",
7    "rootDir": "./src",
8    "strict": true,
9    "esModuleInterop": true,
10    "skipLibCheck": true
11  },
12  "include": ["src/**/*"]
13}

1{
2  "type": "module",
3  "scripts": {
4    "build": "tsc",
5    "start": "node build/index.js"
6  }
7}

1import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
2import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
3import { z } from "zod";
4 
5// Configuration from environment
6const API_URL = process.env.METRICS_API_URL || "https://api.example.com";
7const API_KEY = process.env.METRICS_API_KEY || "";
8 
9// Helper for API calls
10async function apiFetch<T>(endpoint: string): Promise<T | null> {
11  try {
12    const response = await fetch(`${API_URL}${endpoint}`, {
13      headers: {
14        Authorization: `Bearer ${API_KEY}`,
15        Accept: "application/json",
16      },
17    });
18    if (!response.ok) {
19      console.error(`API error: ${response.status}`);
20      return null;
21    }
22    return (await response.json()) as T;
23  } catch (error) {
24    console.error(`Fetch failed: ${error}`);
25    return null;
26  }
27}
28 
29// Initialize the MCP server
30const server = new McpServer({
31  name: "project-metrics",
32  version: "1.0.0",
33});
34 
35// Register a tool: list projects
36server.registerTool(
37  "list_projects",
38  {
39    description: "List all active projects with their current status",
40    inputSchema: {
41      status: z
42        .enum(["active", "completed", "archived"])
43        .optional()
44        .describe("Filter by project status"),
45    },
46  },
47  async ({ status }) => {
48    const endpoint = status ? `/projects?status=${status}` : "/projects";
49    const data = await apiFetch<{ projects: Array<{ name: string; id: string; status: string }> }>(endpoint);
50 
51    if (!data) {
52      return { content: [{ type: "text" as const, text: "Failed to fetch projects." }] };
53    }
54 
55    const list = data.projects
56      .map((p) => `- **${p.name}** (${p.id}) — ${p.status}`)
57      .join("\n");
58 
59    return {
60      content: [{ type: "text" as const, text: `## Projects\n\n${list}` }],
61    };
62  }
63);
64 
65// Register a tool: get project details
66server.registerTool(
67  "get_project_details",
68  {
69    description: "Get detailed metrics for a specific project",
70    inputSchema: {
71      project_id: z.string().describe("The project ID"),
72    },
73  },
74  async ({ project_id }) => {
75    const data = await apiFetch<Record<string, unknown>>(`/projects/${project_id}`);
76 
77    if (!data) {
78      return {
79        content: [{ type: "text" as const, text: `Project ${project_id} not found.` }],
80        isError: true,
81      };
82    }
83 
84    const details = Object.entries(data)
85      .map(([key, value]) => `- **${key}**: ${value}`)
86      .join("\n");
87 
88    return {
89      content: [{ type: "text" as const, text: `## Project Details\n\n${details}` }],
90    };
91  }
92);
93 
94// Register a resource: project summary
95server.registerResource(
96  "metrics://summary",
97  "metrics://summary",
98  {
99    description: "High-level summary of all project metrics",
100    mimeType: "text/plain",
101  },
102  async () => {
103    const data = await apiFetch<{ summary: string }>("/summary");
104    return {
105      contents: [
106        {
107          uri: "metrics://summary",
108          text: data?.summary || "Unable to fetch summary.",
109        },
110      ],
111    };
112  }
113);
114 
115// Start the server
116async function main() {
117  const transport = new StdioServerTransport();
118  await server.connect(transport);
119  console.error("Project Metrics MCP Server running on stdio");
120}
121 
122main().catch((error) => {
123  console.error("Fatal error:", error);
124  process.exit(1);
125});

1# Install uv if you haven't already
2curl -LsSf https://astral.sh/uv/install.sh | sh
3 
4# Create and set up the project
5uv init lab-data-mcp
6cd lab-data-mcp
7uv venv
8source .venv/bin/activate
9 
10# Install dependencies
11uv add "mcp[cli]" httpx

1"""Lab Data MCP Server — connects Claude to your lab's data system."""
2 
3from typing import Any
4import httpx
5from mcp.server.fastmcp import FastMCP
6 
7mcp = FastMCP("lab-data")
8 
9API_BASE = "https://api.yourlab.edu/v1"
10API_TOKEN = ""  # Set via environment variable
11 
12 
13async def api_get(endpoint: str) -> dict[str, Any] | None:
14    """Make an authenticated GET request to the lab API."""
15    headers = {"Authorization": f"Bearer {API_TOKEN}", "Accept": "application/json"}
16    async with httpx.AsyncClient() as client:
17        try:
18            response = await client.get(f"{API_BASE}{endpoint}", headers=headers, timeout=30.0)
19            response.raise_for_status()
20            return response.json()
21        except Exception as e:
22            print(f"Request failed: {e}", flush=True)
23            return None
24 
25 
26@mcp.tool()
27async def list_datasets(project: str | None = None, limit: int = 20) -> str:
28    """List available datasets in the lab data system.
29 
30    Args:
31        project: Filter by project name (optional)
32        limit: Maximum number of datasets to return (default 20)
33    """
34    endpoint = f"/datasets?limit={limit}"
35    if project:
36        endpoint += f"&project={project}"
37 
38    data = await api_get(endpoint)
39    if not data or "datasets" not in data:
40        return "Unable to fetch datasets."
41 
42    lines = []
43    for ds in data["datasets"]:
44        lines.append(
45            f"- **{ds['name']}** ({ds['id']})\n"
46            f"  Project: {ds.get('project', 'N/A')} | "
47            f"Rows: {ds.get('row_count', '?')}"
48        )
49    return "## Datasets\n\n" + "\n\n".join(lines)
50 
51 
52@mcp.tool()
53async def query_dataset(dataset_id: str, sql: str, limit: int = 100) -> str:
54    """Run a SQL query against a lab dataset.
55 
56    Args:
57        dataset_id: The ID of the dataset to query
58        sql: SQL query to execute (SELECT only)
59        limit: Maximum rows to return (default 100)
60    """
61    if not sql.strip().upper().startswith("SELECT"):
62        return "Error: Only SELECT queries are allowed."
63 
64    # POST the query to the API
65    async with httpx.AsyncClient() as client:
66        response = await client.post(
67            f"{API_BASE}/datasets/{dataset_id}/query",
68            json={"sql": sql, "limit": limit},
69            headers={"Authorization": f"Bearer {API_TOKEN}"},
70            timeout=30.0,
71        )
72        if not response.is_success:
73            return f"Query failed: {response.status_code}"
74        result = response.json()
75 
76    columns = result.get("columns", [])
77    rows = result.get("rows", [])
78    if not rows:
79        return "Query returned no results."
80 
81    header = " | ".join(columns)
82    separator = " | ".join(["---"] * len(columns))
83    body = "\n".join(" | ".join(str(cell) for cell in row) for row in rows)
84    return f"**Results** ({len(rows)} rows):\n\n{header}\n{separator}\n{body}"
85 
86 
87@mcp.resource("lab://projects/active")
88async def active_projects() -> str:
89    """List all currently active research projects."""
90    data = await api_get("/projects?status=active")
91    if not data:
92        return "Unable to fetch active projects."
93    return "\n".join(
94        f"{p['name']} ({p['id']}): {p.get('description', 'No description')}"
95        for p in data.get("projects", [])
96    )
97 
98 
99@mcp.prompt()
100def analyze_dataset(dataset_name: str) -> str:
101    """Generate a prompt for Claude to analyze a dataset.
102 
103    Args:
104        dataset_name: Name of the dataset to analyze
105    """
106    return (
107        f"Please analyze the '{dataset_name}' dataset. "
108        f"List columns and types, provide summary statistics, "
109        f"identify anomalies, and suggest interesting analyses."
110    )
111 
112 
113def main():
114    mcp.run(transport="stdio")
115 
116 
117if __name__ == "__main__":
118    main()

claude mcp add lab-data -- uv --directory /absolute/path/to/lab-data-mcp run server.py

1# Inspect a TypeScript server
2npx @modelcontextprotocol/inspector node /path/to/build/index.js
3 
4# Inspect a Python server
5npx @modelcontextprotocol/inspector uv --directory /path/to/server run server.py

# Send a raw JSON-RPC initialize request
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' | node build/index.js 2>/dev/null | jq .

1const cache = new Map<string, { data: unknown; expires: number }>();
2 
3function getCached<T>(key: string): T | null {
4  const entry = cache.get(key);
5  if (!entry || Date.now() > entry.expires) {
6    cache.delete(key);
7    return null;
8  }
9  return entry.data as T;
10}
11 
12function setCache(key: string, data: unknown, ttlMs = 60_000): void {
13  cache.set(key, { data, expires: Date.now() + ttlMs });
14}

1import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
2import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
3import express from "express";
4 
5const app = express();
6app.use(express.json());
7 
8const server = new McpServer({ name: "remote-metrics", version: "1.0.0" });
9 
10// Register tools...
11 
12const transport = new StreamableHTTPServerTransport({
13  sessionIdGenerator: undefined, // Stateless mode
14});
15 
16app.post("/mcp", async (req, res) => {
17  await transport.handleRequest(req, res, req.body);
18});
19 
20await server.connect(transport);
21app.listen(3001, () => {
22  console.error("Remote MCP server at http://localhost:3001/mcp");
23});

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

from mcp.server.fastmcp import FastMCP
mcp = FastMCP("your-server-name")