@ampeco/public-api-mcp 0.2.0 → 0.3.0

package/README.md

@@ -19,7 +19,7 @@ claude mcp add --transport stdio ampeco-api-dev \
 # One-liner to add production server
 claude mcp add --transport stdio ampeco-api \
   --env AMPECO_BEARER_TOKEN=your-token-here \
-  -- npx -y @ampeco/public-api-mcp --stdio --hostname http://demo.charge.alex2.dev.ampeco.tech
+  -- npx -y @ampeco/public-api-mcp --stdio --hostname https://api.example.com
 ```
 
 ### HTTP Mode (Remote Server)
@@ -30,7 +30,7 @@ PORT=3001 npm run dev:http
 
 # Then add to Claude Code
 claude mcp add --transport http ampeco-api \
-  http://localhost:3001/demo.charge.alex2.dev.ampeco.tech \
+  http://localhost:3001/api.example.com \
   --header "Authorization: Bearer your-token-here"
 ```
 
@@ -40,83 +40,6 @@ See [Setting Up with Claude Code](#setting-up-with-claude-code) for detailed ins
 
 This project transforms OpenAPI specifications into optimized, self-contained API definitions that can be served through the Model Context Protocol. It features a sophisticated build pipeline that processes OpenAPI specs at build time to minimize runtime overhead and reduce token usage.
 
-## Phase 1: Build Pipeline Foundation ✅
-
-### Completed Features
-
-#### 1. OpenAPI Parsing Module with Dereferencing
-- ✅ Loads and bundles OpenAPI 3 specifications (JSON/YAML)
-- ✅ Resolves external file references
-- ✅ Handles circular references automatically
-- ✅ Creates self-contained endpoint definitions
-
-**Location**: `src/build/parser.ts`
-
-#### 2. Schema Flattening
-- ✅ Flattens `allOf` compositions by merging properties
-- ✅ Resolves nested schemas to reduce complexity
-- ✅ Handles `anyOf`, `oneOf`, and complex schema constructs
-- ✅ Deep merging of object properties
-
-**Location**: `src/build/flattener.ts`
-
-#### 3. Security Embedding Logic
-- ✅ Embeds full security scheme details per endpoint
-- ✅ Includes authentication type, scheme, and usage instructions
-- ✅ Eliminates references to shared security components
-- ✅ Generates human-readable authentication descriptions
-
-**Location**: `src/build/security-embedder.ts`
-
-#### 4. Optimization and Minification
-- ✅ Removes redundant whitespace and empty keys
-- ✅ Optimizes schema definitions
-- ✅ **Achieved 22.39% size reduction** on target API
-- ✅ Calculates and reports optimization statistics
-
-**Location**: `src/build/optimizer.ts`
-
-#### 5. Zod Schema Generation
-- ✅ Converts OpenAPI schemas to Zod validation schemas
-- ✅ Supports complex types, enums, unions, and validation rules
-- ✅ Handles edge cases (null enums, single-element unions, number enums)
-- ✅ Generates TypeScript code for runtime validation
-
-**Location**: `src/build/zod-generator.ts`
-
-### Build Statistics
-
-Successfully processed the AMPECO.CHARGE Public API (v3.96.4):
-
-```
-Total Endpoints:    443
-Original Size:      809,161 bytes
-Optimized Size:     628,009 bytes
-Size Reduction:     22.39%
-Build Duration:     ~1 second
-```
-
-### Generated Artifacts
-
-The build pipeline produces three files in `src/generated/`:
-
-1. **`endpoints.json`** (1.2MB)
-   - Optimized endpoint definitions
-   - Fully dereferenced schemas
-   - Embedded security requirements
-   - API metadata and build statistics
-
-2. **`schemas.ts`** (122KB)
-   - Generated Zod validation schemas
-   - Type-safe parameter validation
-   - Request body schemas
-   - Auto-generated from OpenAPI spec
-
-3. **`build-stats.json`**
-   - Build metrics
-   - Optimization statistics
-   - Performance data
-
 ## Usage
 
 ### Running the Build Pipeline
@@ -138,14 +61,13 @@ npm run dev
 ```
 
 The build script:
-1. Parses the OpenAPI spec from the specified path (defaults to `../backend/main/docs/public.yaml`)
+1. Parses the OpenAPI spec from the specified path
 2. Processes all endpoints through the optimization pipeline
 3. Generates Zod schemas for runtime validation
 4. Outputs optimized artifacts to `src/generated/`
 
 **Configuration Options:**
 - **`OPENAPI_SPEC_PATH`**: Path to the OpenAPI YAML/JSON file (relative or absolute)
-  - Default: `../backend/main/docs/public.yaml`
   - Can be set as an environment variable or passed directly to npm commands
   - Used by both `npm run build` and `npm run dev`
 
@@ -172,8 +94,6 @@ OpenAPI Spec
     ↓
 [Flattener] Flatten Schemas (allOf, nested objects)
     ↓
-[Security] Embed Authentication Details
-    ↓
 [Optimizer] Minify & Optimize
     ↓
 [Zod Generator] Generate Validation Schemas
@@ -181,115 +101,30 @@ OpenAPI Spec
 Generated Artifacts (endpoints.json, schemas.ts)
 ```
 
-### Module Structure
-
-```
-src/
-├── build/                    # Build-time pipeline
-│   ├── index.ts             # Pipeline orchestrator
-│   ├── parser.ts            # OpenAPI parsing & bundling
-│   ├── flattener.ts         # Schema flattening logic
-│   ├── security-embedder.ts # Security details embedding
-│   ├── optimizer.ts         # Optimization & minification
-│   ├── zod-generator.ts     # Zod schema generation
-│   └── types.ts             # Build pipeline types
-│
-├── cli/                     # CLI entry point
-│   └── index.ts             # Argument parsing & mode selection
-│
-├── server/                  # Runtime MCP server
-│   ├── factory.ts           # Shared server creation logic
-│   ├── loader.ts            # Endpoint loading module
-│   ├── prompts.ts           # Workflow prompt handlers
-│   ├── stdio.ts             # Stdio transport server
-│   ├── http.ts              # HTTP transport server
-│   ├── index.ts             # (Legacy - kept for reference)
-│   └── factory.test.ts      # Unit tests
-│
-└── generated/               # Build output (gitignored)
-    ├── endpoints.json       # Optimized endpoints (~1.2MB)
-    ├── schemas.ts           # Zod validation schemas (~122KB)
-    └── build-stats.json     # Build statistics
-```
-
-## Key Features
-
-### Zero Runtime Overhead
-All OpenAPI processing happens at build time. The server loads pre-processed, optimized data instantly.
-
-### Comprehensive Dereferencing
-Resolves all `$ref` pointers (external files, internal components) to create fully self-contained endpoint definitions.
-
-### Intelligent Schema Flattening
-- Merges `allOf` compositions
-- Resolves nested complexity
-- Handles circular references
-
-### Embedded Security Documentation
-Each endpoint includes complete authentication instructions:
-- Bearer token: "Include token in Authorization header as: Authorization: Bearer <token>"
-- API key, OAuth, and other schemes fully documented
-
-### Token Optimization
-Aggressive optimization targeting 50-70% token reduction through:
-- Redundant data removal
-- Whitespace minimization
-- Essential-only field retention
-
-### Type Safety
-- Generated Zod schemas for runtime validation
-- TypeScript types for compile-time safety
-- Validates parameters before API calls
-
-## Phase 2: MCP Server Core ✅
-
-### Completed Features
-
-#### 1. Streamable HTTP Transport Server
-- ✅ Express-based HTTP server with MCP transport
-- ✅ Stateless design (no session management)
-- ✅ CORS-enabled for browser clients
-- ✅ Health check endpoint at `/health`
-- ✅ MCP protocol endpoint at `/mcp`
-
-**Location**: `src/server/index.ts`
-
-#### 2. Dynamic Resource Handlers
-- ✅ **Resources List**: Exposes all 443 API endpoints as MCP resources
-- ✅ **Resources Read**: Returns complete endpoint details
-  - Path, method, operationId, descriptions
-  - Request/response schemas (flattened and optimized)
-  - Embedded security information
-  - Parameter definitions with validation rules
-
-#### 3. HTTP Request Tool
-- ✅ Fully typed `api_request` tool with Zod validation
-- ✅ Parameters:
-  - `hostname`: API base URL
-  - `bearer_token`: Authentication token
-  - `endpoint`: API path with parameter substitution
-  - `method`: HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)
-  - `path_params`: Path parameter values
-  - `query_params`: Query string parameters
-  - `body`: Request payload
-  - `headers`: Additional HTTP headers
-- ✅ Automatic Bearer token authentication
-- ✅ Structured responses (status, headers, body)
-
-#### 4. Error Handling & Logging
-- ✅ Request/response logging to console
-- ✅ Graceful error handling with JSON-RPC error responses
-- ✅ Connection cleanup on request close
-
-### Server Features
-
-**Stateless Architecture**: No session state required - hostname and auth tokens provided per request
-
-**Zero Configuration**: No config files needed - all parameters passed at runtime
-
-**Fast Startup**: Pre-processed endpoint data loads instantly
-
-**MCP Protocol Compliance**: Fully implements MCP Streamable HTTP transport specification
+### MCP Server
+
+The server provides a complete MCP implementation for accessing your OpenAPI-defined API:
+
+- **Dual Transport Support**: Both Stdio (local) and HTTP (remote) transports
+- **Flexible Resource Mode**: Native MCP resources OR tool-based emulation for Claude Desktop compatibility
+- **Dynamic Resources**: All API endpoints exposed as MCP resources with full schema details
+- **API Request Tool**: Fully typed `api_request` tool with automatic authentication and parameter validation
+- **Stateless Architecture**: No session state required - all parameters provided per request
+- **Zero Configuration**: Pre-processed data loads instantly, no config files needed
+- **MCP Protocol Compliance**: Full implementation of MCP Streamable HTTP transport specification
+
+#### Resource Modes
+
+The server supports two modes for exposing API endpoints:
+
+1. **Native Resources Mode** (Default): Uses native MCP resources for endpoint discovery
+   - Best for: MCP clients that fully support the resources capability
+   - Features: Hierarchical 3-tier navigation (tags → endpoints → details)
+
+2. **Tool Emulation Mode**: Exposes resources through tools (`list_resources`, `read_resource`)
+   - **Required for Claude Desktop** (does not support native MCP resources)
+   - Provides identical functionality through tool-based interface
+   - Enable with `--emulate-resources-via-tools` flag
 
 ### Running the Server
 
@@ -318,7 +153,161 @@ The server uses a hostname-based routing structure where the target API hostname
 - `POST /api.example.com` → Routes to `https://api.example.com`
 - `POST /api.example.com/https` → Routes to `https://api.example.com`
 - `POST /api.example.com/http` → Routes to `http://api.example.com`
-- `POST /demo.charge.dev.ampeco.tech/http` → Routes to `http://demo.charge.dev.ampeco.tech`
+- `POST /internal.api.company.com/http` → Routes to `http://internal.api.company.com`
+
+## Setting Up with Claude Desktop
+
+**IMPORTANT**: Claude Desktop **does not support native MCP resources**. You **MUST** use the `--emulate-resources-via-tools` flag for Claude Desktop.
+
+### Claude Desktop Configuration
+
+Claude Desktop uses a configuration file called `claude_desktop_config.json` located at:
+
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+You can also access this file through Claude Desktop: **Settings** → **Developer** → **Edit Config**
+
+### Configuration Example
+
+Add this to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "ampeco-api": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@ampeco/public-api-mcp",
+        "--stdio",
+        "--hostname",
+        "https://api.example.com",
+        "--emulate-resources-via-tools"
+      ],
+      "env": {
+        "AMPECO_BEARER_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+**Replace**:
+- `https://api.example.com` with your actual API hostname
+- `your-token-here` with your bearer token
+
+**After editing the file**, restart Claude Desktop for changes to take effect
+
+### What is Tool Emulation Mode?
+
+When `--emulate-resources-via-tools` is enabled, the server provides two additional tools:
+
+1. **`list_resources`**: Discover available API tags (e.g., Users, ChargingSessions)
+   - No parameters required
+   - Returns list of tags that group related endpoints
+
+2. **`read_resource`**: Read endpoint definitions by URI
+   - Parameter: `uri` (e.g., `tag://Users` or `api://GET/users/{id}`)
+   - Returns full endpoint specification
+
+These tools provide **identical functionality** to native MCP resources but work through the tools interface that Claude Desktop supports.
+
+### Tool Schemas (Emulation Mode)
+
+When `--emulate-resources-via-tools` is enabled, the following tools are available:
+
+#### `list_resources` Tool
+
+**Description**: List all available API tags. This emulates the native MCP resources/list functionality. Returns a list of tags that group related endpoints together (e.g., Users, ChargingSessions, Connectors). Each tag can then be read using the read_resource tool with tag:// URIs.
+
+**Parameters**: None
+
+**Returns**: JSON object with `resources` array containing:
+```json
+{
+  "resources": [
+    {
+      "uri": "tag://Users",
+      "name": "Users",
+      "description": "15 endpoints tagged with 'Users'",
+      "mimeType": "application/json"
+    },
+    {
+      "uri": "tag://ChargingSessions",
+      "name": "ChargingSessions",
+      "description": "8 endpoints tagged with 'ChargingSessions'",
+      "mimeType": "application/json"
+    }
+  ]
+}
+```
+
+**Example Usage**:
+```
+Call list_resources tool → Get list of all API tags
+```
+
+#### `read_resource` Tool
+
+**Description**: Read a specific resource by URI. This emulates the native MCP resources/read functionality. Supports two URI formats: tag://{TagName} to read all endpoints within a tag, and api://{METHOD}{path} to read detailed endpoint specifications. You MUST use this tool to read endpoint definitions before calling api_request.
+
+**Parameters**:
+- `uri` (string, required): The resource URI to read
+  - Format: `tag://{TagName}` or `api://{METHOD}{path}`
+  - Examples: `"tag://Users"`, `"api://GET/users/{id}"`, `"api://POST/charging-sessions"`
+
+**Returns** (for tag URIs):
+```json
+{
+  "tag": "Users",
+  "count": 15,
+  "endpoints": [
+    {
+      "uri": "api://GET/users/{id}",
+      "method": "GET",
+      "path": "/users/{id}",
+      "summary": "Get user by ID",
+      "operationId": "getUser"
+    }
+  ]
+}
+```
+
+**Returns** (for api URIs):
+```json
+{
+  "path": "/users/{id}",
+  "method": "GET",
+  "operationId": "getUser",
+  "summary": "Get user by ID",
+  "description": "Retrieves detailed information about a specific user",
+  "parameters": [...],
+  "requestBody": {...},
+  "responses": {...},
+  "security": "Include token in Authorization header as: Authorization: Bearer <token>"
+}
+```
+
+**Example Usage**:
+```
+1. Call read_resource with uri="tag://Users" → Get all endpoints in Users tag
+2. Call read_resource with uri="api://GET/users/{id}" → Get full endpoint specification
+3. Call api_request with correct parameters → Make the actual API call
+```
+
+### When to Use Each Mode
+
+| Mode | Use For | Clients |
+|------|---------|---------|
+| **Native Resources** (default) | MCP clients that fully support resources | **Claude Code**, MCP Inspector |
+| **Tool Emulation** (`--emulate-resources-via-tools`) | Clients without resource support | **Claude Desktop** |
+
+**Important Distinction**:
+- **Claude Code** (the CLI tool): Supports native MCP resources - use **default mode**
+- **Claude Desktop** (the desktop app): Does NOT support resources - use **`--emulate-resources-via-tools`**
+
+**Rule of thumb**: If you're using **Claude Desktop**, always add `--emulate-resources-via-tools`. If using **Claude Code**, use default mode.
 
 ## Setting Up with Claude Code
 
@@ -382,25 +371,32 @@ For production use without needing the source code:
 #### Option 1: One-Liner (Recommended)
 
 ```bash
-# Add production server with a single command
+# Add production server with a single command (native resources)
 claude mcp add --transport stdio ampeco-api \
   --env AMPECO_BEARER_TOKEN=your-token-here \
-  -- npx -y @ampeco/public-api-mcp --stdio --hostname http://demo.charge.alex2.dev.ampeco.tech
+  -- npx -y @ampeco/public-api-mcp --stdio --hostname https://api.example.com
+
+# With tool emulation mode (if client doesn't support resources)
+claude mcp add --transport stdio ampeco-api \
+  --env AMPECO_BEARER_TOKEN=your-token-here \
+  -- npx -y @ampeco/public-api-mcp --stdio --hostname https://api.example.com --emulate-resources-via-tools
 ```
 
 **Replace**:
 - `your-token-here` with your API token
-- `http://demo.charge.alex2.dev.ampeco.tech` with your target API hostname
+- `https://api.example.com` with your target API hostname
 
 **Features**:
 - NPX downloads and caches the package automatically
 - No source code or build required
 - Works from any directory
+- Add `--emulate-resources-via-tools` for Claude Desktop compatibility
 
 #### Option 2: Manual Configuration
 
 Create `.mcp.json` in your project or home directory:
 
+**Native Resources Mode**:
 ```json
 {
   "mcpServers": {
@@ -412,7 +408,30 @@ Create `.mcp.json` in your project or home directory:
         "@ampeco/public-api-mcp",
         "--stdio",
         "--hostname",
-        "http://demo.charge.alex2.dev.ampeco.tech"
+        "https://api.example.com"
+      ],
+      "env": {
+        "AMPECO_BEARER_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+**Tool Emulation Mode** (for Claude Desktop):
+```json
+{
+  "mcpServers": {
+    "ampeco-api": {
+      "type": "stdio",
+      "command": "npx",
+      "args": [
+        "-y",
+        "@ampeco/public-api-mcp",
+        "--stdio",
+        "--hostname",
+        "https://api.example.com",
+        "--emulate-resources-via-tools"
       ],
       "env": {
         "AMPECO_BEARER_TOKEN": "your-token-here"
@@ -442,20 +461,46 @@ npm install -g @ampeco/public-api-mcp
 #### 2. Add to Claude Code (One-Liner)
 
 ```bash
-# Add globally installed server
+# Add globally installed server (native resources)
+claude mcp add --transport stdio ampeco-api \
+  --env AMPECO_BEARER_TOKEN=your-token-here \
+  -- ampeco-api-mcp --stdio --hostname https://api.example.com
+
+# With tool emulation mode (for Claude Desktop)
 claude mcp add --transport stdio ampeco-api \
   --env AMPECO_BEARER_TOKEN=your-token-here \
-  -- ampeco-api-mcp --stdio --hostname http://demo.charge.alex2.dev.ampeco.tech
+  -- ampeco-api-mcp --stdio --hostname https://api.example.com --emulate-resources-via-tools
 ```
 
 **Or manual configuration** in `.mcp.json`:
+
+**Native Resources Mode**:
 ```json
 {
   "mcpServers": {
     "ampeco-api": {
       "type": "stdio",
       "command": "ampeco-api-mcp",
-      "args": ["--stdio", "--hostname", "http://demo.charge.alex2.dev.ampeco.tech"],
+      "args": ["--stdio", "--hostname", "https://api.example.com"],
+      "env": {"AMPECO_BEARER_TOKEN": "your-token-here"}
+    }
+  }
+}
+```
+
+**Tool Emulation Mode** (for Claude Desktop):
+```json
+{
+  "mcpServers": {
+    "ampeco-api": {
+      "type": "stdio",
+      "command": "ampeco-api-mcp",
+      "args": [
+        "--stdio",
+        "--hostname",
+        "https://api.example.com",
+        "--emulate-resources-via-tools"
+      ],
       "env": {"AMPECO_BEARER_TOKEN": "your-token-here"}
     }
   }
@@ -469,12 +514,19 @@ For shared server access or when multiple clients need to connect:
 #### 1. Start the Server
 
 ```bash
-# Development mode
+# Development mode (native resources)
 PORT=3001 npm run dev:http
 
-# Production mode
+# Development mode (tool emulation)
+PORT=3001 npm start -- --http --port 3001 --emulate-resources-via-tools
+
+# Production mode (native resources)
 npm run build  # First time only
 PORT=3001 npm start -- --http --port 3001
+
+# Production mode (tool emulation)
+npm run build  # First time only
+PORT=3001 npm start -- --http --port 3001 --emulate-resources-via-tools
 ```
 
 #### 2. Add to Claude Code (One-Liner)
@@ -482,14 +534,14 @@ PORT=3001 npm start -- --http --port 3001
 ```bash
 # Add HTTP server with a single command
 claude mcp add --transport http ampeco-api \
-  http://localhost:3001/demo.charge.alex2.dev.ampeco.tech \
+  http://localhost:3001/api.example.com \
   --header "Authorization: Bearer your-token-here"
 ```
 
 **With protocol override** (use HTTP for target API instead of HTTPS):
 ```bash
 claude mcp add --transport http ampeco-api \
-  http://localhost:3001/demo.charge.alex2.dev.ampeco.tech/http \
+  http://localhost:3001/api.example.com/http \
   --header "Authorization: Bearer your-token-here"
 ```
 
@@ -499,7 +551,7 @@ claude mcp add --transport http ampeco-api \
   "mcpServers": {
     "ampeco-api-http": {
       "type": "http",
-      "url": "http://localhost:3001/demo.charge.alex2.dev.ampeco.tech",
+      "url": "http://localhost:3001/api.example.com",
       "headers": {"Authorization": "Bearer your-token-here"}
     }
   }
@@ -526,23 +578,6 @@ claude mcp add --transport http ampeco-api \
 
 **Recommendation**: Use **stdio mode** for development and single-user production. Use **HTTP mode** for shared servers or when multiple clients need concurrent access.
 
-### Configuration File Locations
-
-MCP configuration files can be placed at different scopes:
-
-| Scope | Location | Priority | Use Case |
-|-------|----------|----------|----------|
-| **Project** | `.mcp.json` in project root | Highest | Project-specific servers |
-| **User** | `~/.mcp.json` | Medium | Personal cross-project servers |
-| **Claude Code** | Per OS (see below) | N/A | Claude Code-specific |
-
-**Claude Code Configuration Locations:**
-- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
-- Linux: `~/.config/Claude/claude_desktop_config.json`
-
-**Recommendation**: Use project `.mcp.json` for development, user `~/.mcp.json` for production.
-
 ### Troubleshooting
 
 #### Stdio Mode Issues
@@ -614,104 +649,9 @@ npm run build
 - Test the token directly with the API:
   ```bash
   curl -H "Authorization: Bearer your-token" \
-    http://demo.charge.alex2.dev.ampeco.tech/health
+    https://api.example.com/health
   ```
 
-### Other MCP Clients (Claude Desktop, etc.)
-
-For other MCP-enabled tools like Claude Desktop, the configuration is similar:
-
-#### Stdio Configuration
-
-**Location**:
-- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
-- Linux: `~/.config/Claude/claude_desktop_config.json`
-
-```json
-{
-  "mcpServers": {
-    "ampeco-api": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@ampeco/public-api-mcp",
-        "--stdio",
-        "--hostname",
-        "http://demo.charge.alex2.dev.ampeco.tech"
-      ],
-      "env": {
-        "AMPECO_BEARER_TOKEN": "your-api-token-here"
-      }
-    }
-  }
-}
-```
-
-#### HTTP Configuration
-
-If your MCP client supports HTTP transport:
-
-```json
-{
-  "mcpServers": {
-    "ampeco-api": {
-      "type": "http",
-      "url": "http://localhost:3001/demo.charge.alex2.dev.ampeco.tech",
-      "headers": {
-        "Authorization": "Bearer your-api-token-here"
-      }
-    }
-  }
-}
-```
-
-**Server URL Format**: `http://localhost:{port}/{api-hostname}/{protocol}`
-- `{api-hostname}`: Your target API's hostname
-- `{protocol}`: Optional - `http` or `https` (defaults to `https`)
-
-### Testing the Server
-
-```bash
-# Check server health
-curl http://localhost:3001/health
-
-# Test MCP connection with hostname routing
-curl -X POST http://localhost:3001/api.example.com \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your-api-token" \
-  -H "Accept: application/json, text/event-stream" \
-  -d '{
-    "jsonrpc": "2.0",
-    "id": 1,
-    "method": "initialize",
-    "params": {
-      "protocolVersion": "2025-06-18",
-      "capabilities": {},
-      "clientInfo": {
-        "name": "test-client",
-        "version": "1.0.0"
-      }
-    }
-  }'
-```
-
-## Next Steps
-
-### Phase 3: Optimization & Polish
-- [ ] Improve token optimization (target 50-70% reduction)
-- [ ] Enhanced description generation with examples
-- [ ] Performance testing and optimization
-- [ ] Comprehensive test suite
-- [ ] Documentation and usage examples
-
-### Phase 4: Production Readiness
-- [ ] Observability and monitoring integration
-- [ ] Error handling refinement
-- [ ] Validation accuracy testing
-- [ ] Production deployment configuration
-- [ ] Performance benchmarking
-
 ## Technology Stack
 
 ### Runtime