miadi 1.0.14 → 2.0.0

package/package.json

@@ -1,56 +1,24 @@
 {
   "name": "miadi",
-  "version": "1.0.14",
-  "description": "MCP server for Miadi Three-Pathway Agent System API",
-  "main": "dist/index.js",
-  "bin": {
-    "miadi-mcp-server": "dist/index.js",
-    "miadi-mcp-server-remote": "dist/index-remote.js"
-  },
+  "version": "2.0.0",
+  "description": "A software factory for producing relational movies",
+  "main": "index.js",
   "scripts": {
-    "start": "node dist/index.js",
-    "start:remote": "node dist/index-remote.js",
-    "prestart": "npm run build",
-    "prestart:remote": "npm run build:remote",
-    "build:std": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js --external:@modelcontextprotocol/sdk",
-    "build:remote": "esbuild src/index-remote.ts --bundle --platform=node --outfile=dist/index-remote.js --external:@modelcontextprotocol/sdk",
-    "build": "npm run build:std && npm run build:remote",
-    "dev": "nodemon --exec ts-node src/index.ts",
-    "dev:remote": "nodemon --exec ts-node src/index-remote.ts",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": [
-    "mcp",
-    "miadi",
-    "agent",
-    "api",
-    "server"
-  ],
-  "author": "Generated via Gemini MCP",
-  "license": "MIT",
+  "keywords": [],
+  "author": "JGWill",
+  "license": "ISC",
+  "type": "commonjs",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.17.0",
-    "axios": "^1.6.0",
-    "cors": "^2.8.5",
-    "dotenv": "^16.3.0",
-    "express": "^4.18.2",
-    "jsonwebtoken": "^9.0.2",
-    "passport": "^0.7.0",
-    "passport-jwt": "^4.0.1",
-    "uuid": "^9.0.1",
-    "zod": "^3.22.0"
-  },
-  "devDependencies": {
-    "@types/cors": "^2.8.17",
-    "@types/express": "^4.17.21",
-    "@types/jsonwebtoken": "^9.0.5",
-    "@types/node": "^20.10.0",
-    "@types/passport": "^1.0.16",
-    "@types/passport-jwt": "^4.0.1",
-    "@types/uuid": "^9.0.7",
-    "esbuild": "^0.25.8",
-    "nodemon": "^3.0.0",
-    "ts-node": "^10.9.0",
-    "typescript": "^5.3.0"
+    "@miadi/a2a-contracts": "^0.1.1",
+    "@miadi/agent-pi": "^2.0.0",
+    "@miadi/episodic-memory-schema": "^0.2.0",
+    "@miadi/hooks-core": "^0.4.0",
+    "@miadi/inquiry-weave": "^0.2.0",
+    "@miadi/plan-insight": "^0.1.0",
+    "@miadi/tide": "^0.1.4",
+    "@miadi/tide-contract": "^0.1.3",
+    "passages": "^0.1.3"
   }
 }

package/.env.example

@@ -1,28 +0,0 @@
-# Miadi MCP Server Environment Configuration
-# Copy this file to $HOME/.env and configure with your values
-
-# Required: Miadi API Configuration
-EH_TOKEN=your-miadi-api-token-here
-EH_API_URL=https://your-miadi-api-url.com
-
-# Optional: Server Configuration
-NODE_ENV=development
-MCP_PORT=3330
-MCP_HOST=0.0.0.0
-LOG_LEVEL=info
-
-# Optional: ngrok Configuration (dedicated domain)
-NGROK_DOMAIN=__YOUR_CUSTOM_DOMAIN__.ngrok-free.app
-MCP_BASE_URL=https://__YOUR_CUSTOM_DOMAIN__.ngrok-free.app
-
-# Optional: OAuth Configuration
-JWT_SECRET=your-jwt-secret-key-change-in-production
-OAUTH_ISSUER=https://__YOUR_CUSTOM_DOMAIN__.ngrok-free.app/oauth
-
-# Optional: Tool Selection (uncomment to use)
-# MIADI_TOOLS_ENABLED=memory,session,capability
-# MIADI_TOOLS_DISABLED=ai,workflow
-# MIADI_TOOLS_DEFAULT_ENABLED=true
-
-# Optional: CORS Configuration
-# CORS_ORIGINS=https://claude.ai,https://app.claude.ai

package/ARCHITECTURE.md

@@ -1,290 +0,0 @@
-# 🧠 Miadi MCP Server - Architecture Documentation
-
-**Generated**: 2025-07-30  
-**Status**: ✅ **WORKING** - Complete implementation with 26 tools
-
-## 🏗️ Core Architecture Overview
-
-### Bridge Pattern Implementation
-```
-Claude → MCP Tool Calls → MCP Server → HTTP API → Miadi Agent System
-                       ← Tool Results ←          ←               ←
-```
-
-### Key Components
-
-#### 1. **Main Server** (`src/index.ts`)
-- **MCP SDK Integration**: Uses `@modelcontextprotocol/sdk v1.17.0`
-- **StdioServerTransport**: Handles MCP protocol communication
-- **Tool Registration**: 26 tools registered with Zod schemas
-- **Environment Validation**: Validates `EH_TOKEN` and `EH_API_URL` on startup
-
-#### 2. **API Client** (`src/api-client.ts`)
-- **Axios HTTP Client**: Configured with Bearer token authentication
-- **Error Interceptors**: Transform HTTP errors to user-friendly messages
-- **Request/Response Mapping**: TypeScript interfaces for all API endpoints
-- **Timeout Handling**: 30-second timeout with proper error handling
-
-#### 3. **Tool Modules** (`src/tools/*.ts`)
-- **Memory Tools** (`memory-tools.ts`): Redis-based storage operations
-- **Session Tools** (`session-tools.ts`): Agent persona/mode management
-- **Capability Tools** (`capability-tools.ts`): Dynamic capability resolution
-- **AI Tools** (`ai-tools.ts`): OpenAI and generic AI integration
-- **Workflow Tools** (`workflow-tools.ts`): GitHub event handling
-- **Forge Tools** (`forge-tools.ts`): System state management
-
-#### 4. **Type System** (`src/types.ts`)
-- **OpenAPI Derived**: All interfaces from `openapi.yml` specification
-- **Request/Response Types**: Complete type safety for API communication
-- **Error Handling**: Structured error response types
-
-#### 5. **Utilities** (`src/utils.ts`)
-- **Error Handling**: `handleMCPError()` for consistent error responses
-- **Response Formatting**: `createMCPResponse()` for MCP protocol compliance
-- **Logging**: `logToolUsage()` for request tracking
-- **Environment**: `getEnvVar()` for configuration validation
-
-## 🔧 Build System
-
-### Dependencies
-```json
-{
-  "@modelcontextprotocol/sdk": "^1.17.0",
-  "axios": "^1.6.0",
-  "dotenv": "^16.3.0",
-  "zod": "^3.22.0"
-}
-```
-
-### Build Process
-```bash
-# Development build with esbuild
-npm run build
-# esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js --external:@modelcontextprotocol/sdk
-```
-
-### Environment Configuration
-```bash
-EH_TOKEN="your_miadi_api_token"
-EH_API_URL="https://your-api-endpoint.com"
-```
-
-## 🛠️ Tool Registration Pattern
-
-### Complete Tool Example
-```typescript
-server.tool(
-  'miadi-store-memory',
-  'Store data in memory with TTL',
-  {
-    key: z.string().describe('The key to store the memory under'),
-    value: z.string().describe('The value to store'),
-    ttl: z.number().optional().describe('Time to live for the memory in seconds'),
-    type: z.enum(['string', 'hash', 'list']).optional().describe('Type of memory to store'),
-  },
-  async (args: any) => {
-    logToolUsage('miadi-store-memory', args);
-    const { key, value, ttl, type } = args;
-    const result = await memoryTools.storeMemory(key, value, ttl, type);
-    return createMCPResponse(result, 'miadi-store-memory');
-  }
-);
-```
-
-### Tool Categories
-
-#### Memory Operations (9 tools)
-- `miadi-get-memory` - Retrieve memory data from Redis
-- `miadi-store-memory` - Store data with TTL (✅ Complete Zod schema)
-- `miadi-update-memory-ttl` - Update memory TTL
-- `miadi-get-memory-meta` - Get memory metadata
-- `miadi-scan-keys` - Scan Redis keys (✅ Complete Zod schema)
-- `miadi-gather-memory-values` - Gather multiple memory values
-- `miadi-collect-memory` - Collect specific keys
-- `miadi-view-key-content` - View individual key content
-- `miadi-search-cluster` - Search cluster for keys
-
-#### Session Management (6 tools)
-- `miadi-start-session` - Start new agent session (✅ Complete Zod schema)
-- `miadi-get-current-session` - Get current session details
-- `miadi-switch-mode` - Switch mode in existing session
-- `miadi-switch-persona` - Switch persona in session
-- `miadi-end-session` - End active session
-- `miadi-list-sessions` - List active sessions
-
-#### Capability Resolution (3 tools)
-- `miadi-resolve-capabilities` - Resolve capabilities for persona/mode
-- `miadi-get-agent-info` - Get comprehensive agent system info
-- `miadi-detect-cues` - Detect mode/persona switch cues from text
-
-#### AI Integration (2 tools)
-- `miadi-openai-request` - Make OpenAI API requests
-- `miadi-ai-request` - Make generic AI requests
-
-#### Workflow Management (3 tools)
-- `miadi-register-agent` - Register agent for GitHub events
-- `miadi-get-agent-events` - Check for agent events
-- `miadi-get-workflow-howto` - Get workflow setup guides
-
-#### Forge State (3 tools)
-- `miadi-get-forge-state` - Get current forge state
-- `miadi-update-forge-state` - Update forge state
-- `miadi-get-glyph-map` - Get glyph map information
-
-## 🔄 Error Handling Architecture
-
-### Multi-layered Approach
-1. **Axios Interceptors**: Transform HTTP errors to consistent format
-2. **Tool-level Wrapping**: Catch exceptions and provide user-friendly messages
-3. **MCP Response Formatting**: Standardized success/error responses
-4. **Comprehensive Logging**: Request/response logging with `logToolUsage()`
-
-### Error Flow
-```
-API Error → Axios Interceptor → Tool Error Handler → MCP Error Response → Claude
-```
-
-### Error Response Format
-```typescript
-{
-  content: [
-    {
-      type: "text",
-      text: "Error message with context"
-    }
-  ]
-}
-```
-
-## 🧪 Testing Strategy
-
-### Test Categories
-- **Connectivity**: API reachability and authentication
-- **Tool Discovery**: MCP tool registration and schemas
-- **Memory Operations**: Redis-based storage and retrieval
-- **Session Management**: Agent persona/mode workflows
-- **Agent Capabilities**: Capability resolution and cue detection
-
-### Test Results (2025-07-30)
-- ✅ **Server Startup**: Clean startup without errors
-- ✅ **Tool Registration**: All 26 tools successfully registered
-- ✅ **MCP Protocol**: Proper initialization and tool call handling
-- ✅ **API Integration**: Successfully communicates with Miadi API endpoints
-- ⚠️ **Zod Schemas**: 7 complete, 19 with TODO schemas
-- ⚠️ **Parameter Validation**: Some validation tests need improvement
-
-## 🚀 Deployment Configuration
-
-### Claude Desktop Integration
-```json
-{
-  "mcpServers": {
-    "miadi": {
-      "command": "node",
-      "args": ["/absolute/path/to/dist/index.js"],
-      "env": {
-        "EH_TOKEN": "your_token_here",
-        "EH_API_URL": "https://your-api-endpoint.com"
-      }
-    }
-  }
-}
-```
-
-### Production Deployment
-1. **Build**: `npm run build`
-2. **Environment**: Set `EH_TOKEN` and `EH_API_URL`
-3. **Start**: `npm start`
-4. **Monitor**: Check logs for tool usage and errors
-
-## 📊 Performance Characteristics
-
-### Build Output
-- **Size**: 576.0kb (esbuild bundle)
-- **Dependencies**: External MCP SDK dependency
-- **Startup Time**: ~300ms build, instant server start
-
-### API Performance
-- **Timeout**: 30 seconds per request
-- **Rate Limiting**: Built-in protection against API abuse
-- **Error Recovery**: Automatic retry logic for transient failures
-
-## 🔍 Critical Implementation Details
-
-### Zod Schema Completeness
-**CRITICAL**: All MCP tools must have complete Zod parameter schemas. Incomplete schemas (marked with `// TODO: Define Zod schema`) will cause MCP protocol failures.
-
-### MCP Response Format
-All tools must return responses in the correct MCP format:
-```typescript
-{
-  content: [
-    {
-      type: "text",
-      text: "Tool result or error message"
-    }
-  ]
-}
-```
-
-### Environment Validation
-Server exits on startup if required environment variables are missing:
-- `EH_TOKEN`: Bearer authentication token
-- `EH_API_URL`: Base URL for Miadi API
-
-### Type Safety
-Complete TypeScript typing throughout with interfaces derived from OpenAPI specification.
-
-## 🎯 Recreation Checklist
-
-To recreate this MCP server:
-
-1. **Setup Project Structure**
-   - Create `src/` directory with tool modules
-   - Configure `package.json` with dependencies
-   - Set up `tsconfig.json` for TypeScript
-
-2. **Implement Core Components**
-   - `src/index.ts`: Main server with tool registration
-   - `src/api-client.ts`: HTTP client with authentication
-   - `src/types.ts`: TypeScript interfaces from OpenAPI
-   - `src/utils.ts`: Error handling and utilities
-
-3. **Create Tool Modules**
-   - `src/tools/memory-tools.ts`: Redis operations
-   - `src/tools/session-tools.ts`: Session management
-   - `src/tools/capability-tools.ts`: Capability resolution
-   - `src/tools/ai-tools.ts`: AI integration
-   - `src/tools/workflow-tools.ts`: Workflow management
-   - `src/tools/forge-tools.ts`: Forge operations
-
-4. **Configure Build System**
-   - Install esbuild for bundling
-   - Configure external MCP SDK dependency
-   - Set up development and production scripts
-
-5. **Implement Testing**
-   - Create test scripts for each tool category
-   - Set up comprehensive test suite
-   - Configure environment for testing
-
-6. **Deploy and Configure**
-   - Build production bundle
-   - Configure Claude Desktop integration
-   - Set up environment variables
-
-## 🌟 Key Success Factors
-
-1. **Complete Zod Schemas**: All 26 tools need proper parameter validation
-2. **Error Handling**: Comprehensive error handling at all layers
-3. **Type Safety**: Full TypeScript typing throughout
-4. **Testing**: Complete test coverage for all tool categories
-5. **Documentation**: Clear architecture and usage documentation
-
-## 📈 Future Enhancements
-
-1. **Complete Zod Schemas**: Finish parameter validation for all tools
-2. **Enhanced Testing**: Add unit tests and integration tests
-3. **Performance Optimization**: Add caching and connection pooling
-4. **Monitoring**: Add health checks and metrics
-5. **Documentation**: Add tool usage examples and API mapping 

package/CLAUDE.md

@@ -1,269 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-This is a **Model Context Protocol (MCP) server** that acts as a bridge between Claude and the **Miadi Three-Pathway Agent System API**. It exposes 26 MCP tools covering memory operations, session management, capability resolution, AI integration, workflow management, and forge operations.
-
-**🚀 REBUILT USING OFFICIAL MCP SDK** - Now uses proper `StreamableHTTPServerTransport` and official patterns instead of custom HTTP implementation.
-
-**📚 For Future Development**: See [REMOTE_MCP_TRANSFORMATION_GUIDE.md](./REMOTE_MCP_TRANSFORMATION_GUIDE.md) for a comprehensive guide on transforming any standard MCP server into a Claude.ai remote connector.
-
-## Core Architecture
-
-### Bridge Pattern
-```
-Claude.ai → MCP Tool Calls → Remote MCP Server → HTTP API → Miadi Agent System
-                           ← Tool Results ←              ←               ←
-```
-
-### Key Components
-- **Remote Server** (`src/index-remote.ts`): HTTP transport for Claude.ai remote connections  
-- **Local Server** (`src/index.ts`): Standard MCP server for local connections
-- **API Client** (`src/api-client.ts`): HTTP client with Bearer token auth (`EH_TOKEN`)
-- **Tool Modules** (`src/tools/*.ts`): Grouped by functionality (memory, session, AI, etc.)
-- **Type System** (`src/types.ts`): TypeScript interfaces derived from OpenAPI spec
-
-### Critical Configuration
-The server requires these environment variables and will exit on startup if missing:
-- `EH_TOKEN`: Bearer authentication token for Miadi API
-- `EH_API_URL`: Base URL for the Miadi API endpoint
-
-## Development Commands
-
-```bash
-# Build the remote server (for Claude.ai HTTP connections)
-npm run build:remote
-
-# Build the local server (standard MCP)  
-npm run build
-
-# Development mode with auto-reload  
-npm run dev:remote          # Remote server development
-npm run dev                 # Local server development
-
-# Production start (requires build first)
-npm run start:remote        # Remote server for Claude.ai
-npm run start               # Local server for MCP clients
-
-# Start with ngrok tunnel for Claude.ai
-./scripts/start-remote.sh
-
-# Run comprehensive test suite
-./tests/run-all-tests.sh
-
-# Quick validation test
-./tests/quick-test.sh
-
-# Test specific categories
-./tests/test-connectivity.sh        # API connection and auth
-./tests/test-memory-operations.sh   # Memory tool testing
-./tests/test-session-management.sh  # Session workflow testing
-```
-
-## Tool Development Pattern
-
-### Adding New Tools
-1. **Define TypeScript interfaces** in `src/types.ts` (follow OpenAPI spec)
-2. **Implement API client method** in `src/api-client.ts` 
-3. **Create tool function** in appropriate `src/tools/*.ts` file
-4. **Register with Zod schema** in `src/index.ts`
-
-### Tool Registration Format
-```typescript
-server.tool(
-  'tool-name',
-  'Tool description',
-  {
-    // Complete Zod schema - incomplete schemas cause MCP failures
-    param: z.string().describe('Parameter description'),
-    optional: z.number().optional().describe('Optional parameter')
-  },
-  async (args: any) => {
-    logToolUsage('tool-name', args);
-    const result = await toolModule.toolFunction(args.param, args.optional);
-    return createMCPResponse(result, 'tool-name');
-  }
-);
-```
-
-## Error Handling Architecture
-
-### Multi-layered Approach
-1. **Axios Interceptors**: Transform HTTP errors to consistent format
-2. **Tool-level Wrapping**: Catch exceptions and provide user-friendly messages  
-3. **MCP Response Formatting**: Standardized success/error responses
-4. **Comprehensive Logging**: Request/response logging with `logToolUsage()`
-
-### Error Flow
-```
-API Error → Axios Interceptor → Tool Error Handler → MCP Error Response → Claude
-```
-
-## Testing Strategy
-
-### Test Categories
-- **Connectivity**: API reachability and authentication
-- **Tool Discovery**: MCP tool registration and schemas
-- **Memory Operations**: Redis-based storage and retrieval
-- **Session Management**: Agent persona/mode workflows
-- **Agent Capabilities**: Capability resolution and cue detection
-
-### Testing Notes
-- Tests use real API endpoints (not mocked)
-- Environment variables must be configured for tests to pass
-- Each test category can be run independently
-
-## Critical Development Notes
-
-### Zod Schema Completeness
-**CRITICAL**: All MCP tools must have complete Zod parameter schemas. Incomplete schemas (marked with `// TODO: Define Zod schema`) will cause MCP protocol failures and prevent tool invocation.
-
-### Debug Output Interference
-Remove console.error debug statements from production code - they can interfere with MCP JSON-RPC protocol communication.
-
-### Type Safety
-The codebase maintains strict TypeScript typing throughout. All API interfaces in `src/types.ts` are derived from the OpenAPI specification (`openapi.yml`).
-
-### Memory Operation Patterns
-Memory tools support Redis data types with automatic type detection to prevent WRONGTYPE errors. The API client handles type conversion transparently.
-
-## Current Status
-
-✅ **26 tools registered and functional using Official MCP SDK**  
-✅ **Complete rebuild using official MCP TypeScript SDK patterns**  
-✅ **StreamableHTTPServerTransport for proper HTTP handling**  
-✅ **Direct tool registration with server.registerTool()**  
-✅ **Intelligent parameter adapter with automatic parameter routing**  
-✅ **Clean implementation with smart error handling**  
-✅ **Ready for Claude.ai remote connector usage**  
-
-**📁 Files**: Use `src/index-remote.ts` and `./scripts/start-remote.sh` for Claude.ai remote connections.
-
-## Tool Categories
-
-### Memory Operations (8 tools)
-Redis-based storage with pattern matching, TTL support, and type detection
-
-### Session Management (6 tools) 
-Agent persona/mode switching with context override support
-
-### Capability Resolution (3 tools)
-Dynamic capability resolution and natural language cue detection
-
-### AI Integration (2 tools)
-OpenAI and generic AI model request handling
-
-### Workflow Management (3 tools)
-GitHub event handling and agent coordination
-
-### Forge Operations (3 tools)
-System state management and glyph mapping operations
-
-### Cluster Operations (2 tools)
-Distributed key search and content viewing
-
-## Tool Selection System
-
-✅ **Tool Selection Enhancement** - **IMPLEMENTED**
-
-**Status**: Production ready - Environment variable-based tool selection fully implemented
-
-### Configuration Options
-
-The MCP server now supports flexible tool selection via environment variables:
-
-#### Category-based Selection
-```bash
-# Enable entire categories (recommended for simplicity)
-MIADI_TOOLS_ENABLED="memory,session,ai"
-
-# Alternative: Disable specific categories
-MIADI_TOOLS_DISABLED="workflow,forge"
-```
-
-#### Individual Tool Selection
-```bash
-# Enable only specific tools (fine-grained control)
-MIADI_TOOLS_ENABLED="miadi-get-memory,miadi-store-memory,miadi-start-session"
-```
-
-#### Hybrid Approach
-```bash
-# Enable categories with specific exclusions
-MIADI_TOOLS_ENABLED="memory,session,-miadi-collect-memory,-miadi-view-key-content"
-```
-
-#### Default Behavior Control
-```bash
-# Control default enablement when no configuration is provided
-MIADI_TOOLS_DEFAULT_ENABLED="false"  # Default is true
-```
-
-### Tool Categories
-
-- **memory** (9 tools): Redis operations, key scanning, cluster search
-- **session** (6 tools): Agent session management and switching
-- **capability** (3 tools): Capability resolution and agent info
-- **ai** (2 tools): OpenAI and generic AI model requests
-- **workflow** (3 tools): GitHub event handling and agent coordination
-- **forge** (3 tools): System state management and glyph operations
-
-### Benefits Achieved
-
-✅ **Performance**: 70-80% reduction in tool registration overhead for targeted deployments  
-✅ **Security**: Disable sensitive tools (AI, workflow) in restricted environments  
-✅ **Debugging**: Enable only relevant tools during development/testing  
-✅ **Deployment Flexibility**: Different tool sets for different deployment targets  
-✅ **Compliance**: Meet security/regulatory requirements by disabling specific capabilities  
-✅ **Backward Compatibility**: All tools enabled by default when no environment variables set
-
-### Implementation Details
-
-- **ToolRegistry class** manages tool registration with environment-based selection
-- **Comprehensive validation** with warnings for invalid category/tool names
-- **Detailed logging** shows enabled/disabled tool counts and categories on startup
-- **Configuration summary** displays active configuration for debugging
-
-### Usage Examples
-
-#### Development Environment
-```bash
-# Only memory and session tools for lightweight development
-MIADI_TOOLS_ENABLED="memory,session"
-# Result: 15/26 tools enabled
-```
-
-#### Production Environment
-```bash
-# All tools except experimental/dangerous ones
-MIADI_TOOLS_DISABLED="workflow,forge"
-# Result: 18/26 tools enabled
-```
-
-#### Testing Environment
-```bash
-# Only specific tools needed for tests
-MIADI_TOOLS_ENABLED="miadi-get-memory,miadi-store-memory,miadi-start-session"
-# Result: 3/26 tools enabled
-```
-
-#### Security-Constrained Environment
-```bash
-# No AI integration or workflow tools
-MIADI_TOOLS_DISABLED="ai,workflow"
-# Result: 21/26 tools enabled
-```
-
-## 📚 Documentation & Guides
-
-### Transformation Guide
-**[REMOTE_MCP_TRANSFORMATION_GUIDE.md](./REMOTE_MCP_TRANSFORMATION_GUIDE.md)** - Complete guide for transforming any standard MCP server into a Claude.ai remote connector using official SDK patterns.
-
-**Key Resources**:
-- [MCP_LEARNING_NOTES.md](./MCP_LEARNING_NOTES.md) - Analysis of official MCP patterns vs custom implementations
-- [MCP_REBUILD_PLAN.md](./MCP_REBUILD_PLAN.md) - Step-by-step rebuild plan using official SDK
-
-### Success Story
-This project was successfully transformed from a 1,600+ line custom HTTP implementation to a 150-line official SDK implementation with 100% functionality preserved. The transformation guide captures this entire process for reuse by other developers.