@pragmatic-growth/memory-mcp 1.0.0

package/.npmrc.bak

@@ -0,0 +1,2 @@
+@pragmatic-growth:registry=https://registry.npmjs.org/
+//registry.npmjs.org/:_authToken=${NPM_TOKEN}

package/README.md

@@ -0,0 +1,119 @@
+# NT-Memory MCP (stdio)
+
+Local MCP stdio server for NT-Memory tax knowledge base. Use this with Raycast and other stdio-only MCP clients.
+
+## Two Operating Modes
+
+The server supports two modes for different use cases:
+
+### Read-Only Mode (Default)
+Safe for general use - only search and read operations:
+- `search_tax_knowledge` - Semantic search
+- `answer_question` - RAG with auto-generation
+- `get_article` - Get article by ID
+- `list_articles` - Browse articles
+- `list_categories` - List categories with counts
+- `log_unanswered` - Flag gaps
+- `health_check` - System status
+
+### Full Mode (with `--full` flag)
+Includes all read-only tools PLUS write operations:
+- `add_article` - Create new articles
+- `edit_article` - Update existing articles
+- `remove_article` - Soft-delete articles
+- `rate_answer` - Rate previous answers
+
+## Installation
+
+### For Raycast (Read-Only)
+
+```json
+{
+  "name": "nt-memory",
+  "type": "stdio",
+  "command": "npx",
+  "args": ["-y", "@anthropic/nt-memory-mcp"],
+  "env": {
+    "MCP_API_KEY": "your-api-key-here"
+  }
+}
+```
+
+### For Raycast (Full Mode)
+
+```json
+{
+  "name": "nt-memory-full",
+  "type": "stdio",
+  "command": "npx",
+  "args": ["-y", "@anthropic/nt-memory-mcp", "--full"],
+  "env": {
+    "MCP_API_KEY": "your-api-key-here"
+  }
+}
+```
+
+### Global Installation
+
+```bash
+npm install -g @anthropic/nt-memory-mcp
+```
+
+Then run directly:
+
+```bash
+# Read-only mode (default)
+MCP_API_KEY=your-key nt-memory-mcp
+
+# Full mode
+MCP_API_KEY=your-key nt-memory-mcp --full
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `MCP_API_KEY` | Yes | API key for authentication |
+| `MCP_SERVER_URL` | No | Custom server URL (default: production) |
+| `MCP_MODE` | No | Set to `full` to enable write operations |
+
+Note: The `--full` CLI flag takes precedence over `MCP_MODE` env var.
+
+## Available Tools
+
+### Core Tools (All Modes)
+
+| Tool | Description |
+|------|-------------|
+| `search_tax_knowledge` | Search US non-resident tax knowledge base using semantic similarity |
+| `answer_question` | Get AI-powered answers with sources (generates articles if needed) |
+| `get_article` | Retrieve complete article content by ID |
+| `list_articles` | Browse recent articles with optional category filter |
+| `list_categories` | List all categories with article counts |
+| `log_unanswered` | Flag questions as unanswered for gap analysis |
+| `health_check` | Check system status, database connectivity, and current mode |
+
+### Full Mode Tools
+
+| Tool | Description |
+|------|-------------|
+| `add_article` | Create a new article with automatic embedding generation |
+| `edit_article` | Update article content, metadata, or category |
+| `remove_article` | Soft-delete an article (preserves data for audit) |
+| `rate_answer` | Rate previous answers: -1 (unhelpful), 0 (neutral), 1 (helpful) |
+
+## How It Works
+
+This package runs locally as a stdio MCP server and proxies requests to the remote NT-Memory HTTP server on Railway. This allows Raycast (which only supports stdio) to use our cloud-hosted knowledge base.
+
+```
+Raycast (stdio) → nt-memory-mcp (local) → HTTP → Railway (cloud)
+```
+
+The server also respects the remote server's mode configuration. For full mode to work:
+1. The stdio proxy must have `--full` flag OR `MCP_MODE=full`
+2. The remote server must have `MCP_MODE=full` in its environment
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * PG-Memory MCP Stdio Server
+ *
+ * This is a local stdio MCP server that proxies requests to the
+ * remote PG-Memory HTTP server on Railway.
+ *
+ * Usage:
+ *   npx @pragmatic-growth/memory-mcp             # Read-only mode (default)
+ *   npx @pragmatic-growth/memory-mcp --full      # Full mode with edit capabilities
+ *   npx @pragmatic-growth/memory-mcp --edit      # Alias for --full
+ *
+ * Environment variables:
+ *   MCP_API_KEY - API key for authentication (required)
+ *   MCP_SERVER_URL - Server URL (default: https://pg-memory-production.up.railway.app/api/mcp)
+ *   MCP_MODE - Mode: 'readonly' (default) or 'full' for edit capabilities
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+/**
+ * PG-Memory MCP Stdio Server
+ *
+ * This is a local stdio MCP server that proxies requests to the
+ * remote PG-Memory HTTP server on Railway.
+ *
+ * Usage:
+ *   npx @pragmatic-growth/memory-mcp             # Read-only mode (default)
+ *   npx @pragmatic-growth/memory-mcp --full      # Full mode with edit capabilities
+ *   npx @pragmatic-growth/memory-mcp --edit      # Alias for --full
+ *
+ * Environment variables:
+ *   MCP_API_KEY - API key for authentication (required)
+ *   MCP_SERVER_URL - Server URL (default: https://pg-memory-production.up.railway.app/api/mcp)
+ *   MCP_MODE - Mode: 'readonly' (default) or 'full' for edit capabilities
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+// Parse CLI arguments for mode
+const args = process.argv.slice(2);
+const hasFullFlag = args.includes('--full') || args.includes('--edit');
+const envMode = process.env.MCP_MODE?.toLowerCase();
+const isFullMode = hasFullFlag || envMode === 'full' || envMode === 'edit';
+// Configuration
+const SERVER_URL = process.env.MCP_SERVER_URL || 'https://pg-memory-production.up.railway.app/api/mcp';
+const API_KEY = process.env.MCP_API_KEY;
+if (!API_KEY) {
+    console.error('Error: MCP_API_KEY environment variable is required');
+    console.error('Set it in your Raycast MCP server configuration under "env"');
+    process.exit(1);
+}
+// HTTP session management
+let sessionId = null;
+/**
+ * Make an HTTP request to the remote MCP server.
+ */
+async function callRemoteServer(method, params) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${API_KEY}`,
+    };
+    if (sessionId) {
+        headers['Mcp-Session-Id'] = sessionId;
+    }
+    const body = {
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method,
+        params,
+    };
+    const response = await fetch(SERVER_URL, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+    });
+    // Capture session ID from initialize response
+    const newSessionId = response.headers.get('mcp-session-id');
+    if (newSessionId) {
+        sessionId = newSessionId;
+    }
+    const result = await response.json();
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+    return result.result;
+}
+/**
+ * Initialize connection to remote server.
+ */
+async function initializeRemoteSession() {
+    await callRemoteServer('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: {
+            name: 'pg-memory-stdio',
+            version: '1.0.0',
+        },
+    });
+}
+/**
+ * Create and start the stdio MCP server.
+ */
+async function main() {
+    const modeLabel = isFullMode ? 'full' : 'readonly';
+    // Initialize remote session first
+    try {
+        await initializeRemoteSession();
+    }
+    catch (error) {
+        console.error('Failed to connect to remote server:', error);
+        process.exit(1);
+    }
+    // Create local MCP server
+    const server = new McpServer({
+        name: 'pg-memory',
+        version: '1.0.0',
+        description: `PG-Memory knowledge base (${modeLabel} mode)`,
+    });
+    // Register tools that proxy to remote server
+    // These match the tools registered on the remote server
+    server.tool('search_tax_knowledge', 'Search the US non-resident tax compliance knowledge base using semantic similarity', {
+        query: z.string().describe('The tax question or topic to search for'),
+        limit: z.number().optional().describe('Maximum number of results to return (default: 5)'),
+        threshold: z.number().optional().describe('Minimum similarity threshold 0-1 (default: 0.55)'),
+    }, async (args) => {
+        const result = await callRemoteServer('tools/call', {
+            name: 'search_tax_knowledge',
+            arguments: args,
+        });
+        return result;
+    });
+    server.tool('answer_question', 'Answer a tax question using the knowledge base with RAG', {
+        question: z.string().describe('The tax question to answer'),
+        context: z.string().optional().describe('Additional context'),
+    }, async (args) => {
+        const result = await callRemoteServer('tools/call', {
+            name: 'answer_question',
+            arguments: args,
+        });
+        return result;
+    });
+    server.tool('get_article', 'Retrieve the complete content of a knowledge base article by its ID', {
+        article_id: z.string().describe('The article ID (e.g., art_abc123)'),
+    }, async (args) => {
+        const result = await callRemoteServer('tools/call', {
+            name: 'get_article',
+            arguments: args,
+        });
+        return result;
+    });
+    server.tool('list_articles', 'List recent articles from the knowledge base', {
+        limit: z.number().optional().describe('Maximum articles (default: 10)'),
+        category: z.string().optional().describe('Filter by category'),
+    }, async (args) => {
+        const result = await callRemoteServer('tools/call', {
+            name: 'list_articles',
+            arguments: args,
+        });
+        return result;
+    });
+    server.tool('log_unanswered', 'Explicitly flag a question as unanswered for gap analysis', {
+        query: z.string().describe('The question that could not be answered'),
+        reason: z.string().optional().describe('Reason why the question could not be answered'),
+    }, async (args) => {
+        const result = await callRemoteServer('tools/call', {
+            name: 'log_unanswered',
+            arguments: args,
+        });
+        return result;
+    });
+    server.tool('health_check', 'Check the health status of the knowledge base system', {}, async () => {
+        const result = await callRemoteServer('tools/call', {
+            name: 'health_check',
+            arguments: {},
+        });
+        return result;
+    });
+    // Tool 7: List Categories (available in all modes)
+    server.tool('list_categories', 'List all categories in the knowledge base with article counts', {}, async () => {
+        const result = await callRemoteServer('tools/call', {
+            name: 'list_categories',
+            arguments: {},
+        });
+        return result;
+    });
+    // === FULL MODE TOOLS ===
+    // These tools are only available when --full flag is passed or MCP_MODE=full
+    if (isFullMode) {
+        // Tool 8: Add Article
+        server.tool('add_article', 'Create a new article in the knowledge base (full mode only)', {
+            title: z.string().describe('Article title'),
+            content: z.string().describe('Article content in markdown format'),
+            summary: z.string().optional().describe('Brief summary (auto-generated if not provided)'),
+            category: z.string().optional().describe('Category (e.g., federal-tax, state-compliance)'),
+            tags: z.string().optional().describe('Comma-separated tags'),
+            source: z.string().optional().describe('Source of the article (e.g., manual, irs.gov)'),
+        }, async (args) => {
+            const result = await callRemoteServer('tools/call', {
+                name: 'add_article',
+                arguments: args,
+            });
+            return result;
+        });
+        // Tool 9: Edit Article
+        server.tool('edit_article', 'Update an existing article in the knowledge base (full mode only)', {
+            article_id: z.string().describe('Article ID to update'),
+            title: z.string().optional().describe('New title'),
+            content: z.string().optional().describe('New content'),
+            summary: z.string().optional().describe('New summary'),
+            category: z.string().optional().describe('New category'),
+            tags: z.string().optional().describe('New comma-separated tags'),
+        }, async (args) => {
+            const result = await callRemoteServer('tools/call', {
+                name: 'edit_article',
+                arguments: args,
+            });
+            return result;
+        });
+        // Tool 10: Remove Article
+        server.tool('remove_article', 'Soft-delete an article from the knowledge base (full mode only)', {
+            article_id: z.string().describe('Article ID to remove'),
+            reason: z.string().optional().describe('Reason for deletion (for audit log)'),
+        }, async (args) => {
+            const result = await callRemoteServer('tools/call', {
+                name: 'remove_article',
+                arguments: args,
+            });
+            return result;
+        });
+        // Tool 11: Rate Answer
+        server.tool('rate_answer', 'Rate a previous answer as helpful, unhelpful, or neutral (full mode only)', {
+            query_id: z.string().describe('Query log ID from a previous answer_question response'),
+            rating: z.number().describe('Rating: -1 (unhelpful), 0 (neutral), 1 (helpful)'),
+            feedback: z.string().optional().describe('Optional text feedback'),
+        }, async (args) => {
+            const result = await callRemoteServer('tools/call', {
+                name: 'rate_answer',
+                arguments: args,
+            });
+            return result;
+        });
+    }
+    // Connect via stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@pragmatic-growth/memory-mcp",
+  "version": "1.0.0",
+  "description": "MCP stdio client for PG-Memory knowledge base - connect AI agents to your PostgreSQL knowledge base via Model Context Protocol",
+  "main": "dist/index.js",
+  "bin": {
+    "memory-mcp": "./dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "raycast",
+    "knowledge-base",
+    "postgresql",
+    "pgvector",
+    "ai",
+    "rag"
+  ],
+  "author": "Pragmatic Growth",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsx": "^4.19.0",
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pragmaticgrowth/pg-memory.git",
+    "directory": "packages/mcp-stdio"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.ts

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+/**
+ * PG-Memory MCP Stdio Server
+ *
+ * This is a local stdio MCP server that proxies requests to the
+ * remote PG-Memory HTTP server on Railway.
+ *
+ * Usage:
+ *   npx @pragmatic-growth/memory-mcp             # Read-only mode (default)
+ *   npx @pragmatic-growth/memory-mcp --full      # Full mode with edit capabilities
+ *   npx @pragmatic-growth/memory-mcp --edit      # Alias for --full
+ *
+ * Environment variables:
+ *   MCP_API_KEY - API key for authentication (required)
+ *   MCP_SERVER_URL - Server URL (default: https://pg-memory-production.up.railway.app/api/mcp)
+ *   MCP_MODE - Mode: 'readonly' (default) or 'full' for edit capabilities
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+// Parse CLI arguments for mode
+const args = process.argv.slice(2);
+const hasFullFlag = args.includes('--full') || args.includes('--edit');
+const envMode = process.env.MCP_MODE?.toLowerCase();
+const isFullMode = hasFullFlag || envMode === 'full' || envMode === 'edit';
+
+// Configuration
+const SERVER_URL = process.env.MCP_SERVER_URL || 'https://pg-memory-production.up.railway.app/api/mcp';
+const API_KEY = process.env.MCP_API_KEY;
+
+if (!API_KEY) {
+  console.error('Error: MCP_API_KEY environment variable is required');
+  console.error('Set it in your Raycast MCP server configuration under "env"');
+  process.exit(1);
+}
+
+// HTTP session management
+let sessionId: string | null = null;
+
+interface JsonRpcResponse {
+  result?: {
+    content?: Array<{ type: string; text: string }>;
+    [key: string]: unknown;
+  };
+  error?: { message: string };
+}
+
+/**
+ * Make an HTTP request to the remote MCP server.
+ */
+async function callRemoteServer(method: string, params?: Record<string, unknown>): Promise<unknown> {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${API_KEY}`,
+  };
+
+  if (sessionId) {
+    headers['Mcp-Session-Id'] = sessionId;
+  }
+
+  const body = {
+    jsonrpc: '2.0',
+    id: Date.now(),
+    method,
+    params,
+  };
+
+  const response = await fetch(SERVER_URL, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+
+  // Capture session ID from initialize response
+  const newSessionId = response.headers.get('mcp-session-id');
+  if (newSessionId) {
+    sessionId = newSessionId;
+  }
+
+  const result = await response.json() as JsonRpcResponse;
+
+  if (result.error) {
+    throw new Error(result.error.message);
+  }
+
+  return result.result;
+}
+
+/**
+ * Initialize connection to remote server.
+ */
+async function initializeRemoteSession(): Promise<void> {
+  await callRemoteServer('initialize', {
+    protocolVersion: '2024-11-05',
+    capabilities: {},
+    clientInfo: {
+      name: 'pg-memory-stdio',
+      version: '1.0.0',
+    },
+  });
+}
+
+/**
+ * Create and start the stdio MCP server.
+ */
+async function main(): Promise<void> {
+  const modeLabel = isFullMode ? 'full' : 'readonly';
+
+  // Initialize remote session first
+  try {
+    await initializeRemoteSession();
+  } catch (error) {
+    console.error('Failed to connect to remote server:', error);
+    process.exit(1);
+  }
+
+  // Create local MCP server
+  const server = new McpServer({
+    name: 'pg-memory',
+    version: '1.0.0',
+    description: `PG-Memory knowledge base (${modeLabel} mode)`,
+  });
+
+  // Register tools that proxy to remote server
+  // These match the tools registered on the remote server
+
+  server.tool(
+    'search_tax_knowledge',
+    'Search the US non-resident tax compliance knowledge base using semantic similarity',
+    {
+      query: z.string().describe('The tax question or topic to search for'),
+      limit: z.number().optional().describe('Maximum number of results to return (default: 5)'),
+      threshold: z.number().optional().describe('Minimum similarity threshold 0-1 (default: 0.55)'),
+    },
+    async (args) => {
+      const result = await callRemoteServer('tools/call', {
+        name: 'search_tax_knowledge',
+        arguments: args,
+      }) as { content: Array<{ type: 'text'; text: string }> };
+      return result;
+    }
+  );
+
+  server.tool(
+    'answer_question',
+    'Answer a tax question using the knowledge base with RAG',
+    {
+      question: z.string().describe('The tax question to answer'),
+      context: z.string().optional().describe('Additional context'),
+    },
+    async (args) => {
+      const result = await callRemoteServer('tools/call', {
+        name: 'answer_question',
+        arguments: args,
+      }) as { content: Array<{ type: 'text'; text: string }> };
+      return result;
+    }
+  );
+
+  server.tool(
+    'get_article',
+    'Retrieve the complete content of a knowledge base article by its ID',
+    {
+      article_id: z.string().describe('The article ID (e.g., art_abc123)'),
+    },
+    async (args) => {
+      const result = await callRemoteServer('tools/call', {
+        name: 'get_article',
+        arguments: args,
+      }) as { content: Array<{ type: 'text'; text: string }> };
+      return result;
+    }
+  );
+
+  server.tool(
+    'list_articles',
+    'List recent articles from the knowledge base',
+    {
+      limit: z.number().optional().describe('Maximum articles (default: 10)'),
+      category: z.string().optional().describe('Filter by category'),
+    },
+    async (args) => {
+      const result = await callRemoteServer('tools/call', {
+        name: 'list_articles',
+        arguments: args,
+      }) as { content: Array<{ type: 'text'; text: string }> };
+      return result;
+    }
+  );
+
+  server.tool(
+    'log_unanswered',
+    'Explicitly flag a question as unanswered for gap analysis',
+    {
+      query: z.string().describe('The question that could not be answered'),
+      reason: z.string().optional().describe('Reason why the question could not be answered'),
+    },
+    async (args) => {
+      const result = await callRemoteServer('tools/call', {
+        name: 'log_unanswered',
+        arguments: args,
+      }) as { content: Array<{ type: 'text'; text: string }> };
+      return result;
+    }
+  );
+
+  server.tool(
+    'health_check',
+    'Check the health status of the knowledge base system',
+    {},
+    async () => {
+      const result = await callRemoteServer('tools/call', {
+        name: 'health_check',
+        arguments: {},
+      }) as { content: Array<{ type: 'text'; text: string }> };
+      return result;
+    }
+  );
+
+  // Tool 7: List Categories (available in all modes)
+  server.tool(
+    'list_categories',
+    'List all categories in the knowledge base with article counts',
+    {},
+    async () => {
+      const result = await callRemoteServer('tools/call', {
+        name: 'list_categories',
+        arguments: {},
+      }) as { content: Array<{ type: 'text'; text: string }> };
+      return result;
+    }
+  );
+
+  // === FULL MODE TOOLS ===
+  // These tools are only available when --full flag is passed or MCP_MODE=full
+
+  if (isFullMode) {
+    // Tool 8: Add Article
+    server.tool(
+      'add_article',
+      'Create a new article in the knowledge base (full mode only)',
+      {
+        title: z.string().describe('Article title'),
+        content: z.string().describe('Article content in markdown format'),
+        summary: z.string().optional().describe('Brief summary (auto-generated if not provided)'),
+        category: z.string().optional().describe('Category (e.g., federal-tax, state-compliance)'),
+        tags: z.string().optional().describe('Comma-separated tags'),
+        source: z.string().optional().describe('Source of the article (e.g., manual, irs.gov)'),
+      },
+      async (args) => {
+        const result = await callRemoteServer('tools/call', {
+          name: 'add_article',
+          arguments: args,
+        }) as { content: Array<{ type: 'text'; text: string }> };
+        return result;
+      }
+    );
+
+    // Tool 9: Edit Article
+    server.tool(
+      'edit_article',
+      'Update an existing article in the knowledge base (full mode only)',
+      {
+        article_id: z.string().describe('Article ID to update'),
+        title: z.string().optional().describe('New title'),
+        content: z.string().optional().describe('New content'),
+        summary: z.string().optional().describe('New summary'),
+        category: z.string().optional().describe('New category'),
+        tags: z.string().optional().describe('New comma-separated tags'),
+      },
+      async (args) => {
+        const result = await callRemoteServer('tools/call', {
+          name: 'edit_article',
+          arguments: args,
+        }) as { content: Array<{ type: 'text'; text: string }> };
+        return result;
+      }
+    );
+
+    // Tool 10: Remove Article
+    server.tool(
+      'remove_article',
+      'Soft-delete an article from the knowledge base (full mode only)',
+      {
+        article_id: z.string().describe('Article ID to remove'),
+        reason: z.string().optional().describe('Reason for deletion (for audit log)'),
+      },
+      async (args) => {
+        const result = await callRemoteServer('tools/call', {
+          name: 'remove_article',
+          arguments: args,
+        }) as { content: Array<{ type: 'text'; text: string }> };
+        return result;
+      }
+    );
+
+    // Tool 11: Rate Answer
+    server.tool(
+      'rate_answer',
+      'Rate a previous answer as helpful, unhelpful, or neutral (full mode only)',
+      {
+        query_id: z.string().describe('Query log ID from a previous answer_question response'),
+        rating: z.number().describe('Rating: -1 (unhelpful), 0 (neutral), 1 (helpful)'),
+        feedback: z.string().optional().describe('Optional text feedback'),
+      },
+      async (args) => {
+        const result = await callRemoteServer('tools/call', {
+          name: 'rate_answer',
+          arguments: args,
+        }) as { content: Array<{ type: 'text'; text: string }> };
+        return result;
+      }
+    );
+  }
+
+  // Connect via stdio transport
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}