agentdb 1.6.1 → 2.0.0-alpha.2

package/dist/mcp/agentdb-mcp-server.js

@@ -17,7 +17,8 @@ import { LearningSystem } from '../controllers/LearningSystem.js';
 import { EmbeddingService } from '../controllers/EmbeddingService.js';
 import { BatchOperations } from '../optimizations/BatchOperations.js';
 import { ReasoningBank } from '../controllers/ReasoningBank.js';
-import { validateId, validateTimestamp, validateSessionId, ValidationError, handleSecurityError, } from '../security/input-validation.js';
+import { MCPToolCaches } from '../optimizations/ToolCache.js';
+import { validateId, validateTimestamp, validateSessionId, validateTaskString, validateNumericRange, validateArrayLength, validateBoolean, validateEnum, ValidationError, handleSecurityError, } from '../security/input-validation.js';
 import * as path from 'path';
 import * as fs from 'fs';
 import { fileURLToPath } from 'url';
@@ -230,6 +231,7 @@ const learner = new NightlyLearner(db, embeddingService);
 const learningSystem = new LearningSystem(db, embeddingService);
 const batchOps = new BatchOperations(db, embeddingService);
 const reasoningBank = new ReasoningBank(db, embeddingService);
+const caches = new MCPToolCaches();
 // ============================================================================
 // MCP Server Setup
 // ============================================================================
@@ -711,6 +713,122 @@ const tools = [
             },
         },
     },
+    // ==========================================================================
+    // BATCH OPERATION TOOLS (v2.0 MCP Optimization - Phase 2)
+    // ==========================================================================
+    {
+        name: 'skill_create_batch',
+        description: 'Batch create multiple skills efficiently using transactions and parallel embedding generation. 3x faster than sequential skill_create calls (304 → 900 ops/sec). 🔄 PARALLEL-SAFE: Can be used alongside other batch operations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                skills: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Skill name (unique)' },
+                            description: { type: 'string', description: 'What the skill does' },
+                            signature: { type: 'object', description: 'Optional function signature' },
+                            code: { type: 'string', description: 'Skill implementation code' },
+                            success_rate: { type: 'number', description: 'Initial success rate (0-1)', default: 0.0 },
+                            uses: { type: 'number', description: 'Initial use count', default: 0 },
+                            avg_reward: { type: 'number', description: 'Average reward', default: 0.0 },
+                            avg_latency_ms: { type: 'number', description: 'Average latency', default: 0.0 },
+                            tags: { type: 'array', items: { type: 'string' }, description: 'Tags for categorization' },
+                            metadata: { type: 'object', description: 'Additional metadata (JSON)' },
+                        },
+                        required: ['name', 'description'],
+                    },
+                    description: 'Array of skills to create',
+                    minItems: 1,
+                    maxItems: 100,
+                },
+                batch_size: { type: 'number', description: 'Batch size for processing (default: 32)', default: 32 },
+                format: {
+                    type: 'string',
+                    enum: ['concise', 'detailed', 'json'],
+                    description: 'Response format (default: concise)',
+                    default: 'concise',
+                },
+            },
+            required: ['skills'],
+        },
+    },
+    {
+        name: 'reflexion_store_batch',
+        description: 'Batch store multiple episodes efficiently using transactions and parallel embedding generation. 3.3x faster than sequential reflexion_store calls (152 → 500 ops/sec). 🔄 PARALLEL-SAFE: Can be used alongside other batch operations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                episodes: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            session_id: { type: 'string', description: 'Session identifier' },
+                            task: { type: 'string', description: 'Task description' },
+                            reward: { type: 'number', description: 'Task reward (0-1)' },
+                            success: { type: 'boolean', description: 'Whether task succeeded' },
+                            critique: { type: 'string', description: 'Self-critique reflection' },
+                            input: { type: 'string', description: 'Task input' },
+                            output: { type: 'string', description: 'Task output' },
+                            latency_ms: { type: 'number', description: 'Execution latency' },
+                            tokens: { type: 'number', description: 'Tokens used' },
+                            tags: { type: 'array', items: { type: 'string' }, description: 'Tags' },
+                            metadata: { type: 'object', description: 'Additional metadata' },
+                        },
+                        required: ['session_id', 'task', 'reward', 'success'],
+                    },
+                    description: 'Array of episodes to store',
+                    minItems: 1,
+                    maxItems: 1000,
+                },
+                batch_size: { type: 'number', description: 'Batch size for processing (default: 100)', default: 100 },
+                format: {
+                    type: 'string',
+                    enum: ['concise', 'detailed', 'json'],
+                    description: 'Response format (default: concise)',
+                    default: 'concise',
+                },
+            },
+            required: ['episodes'],
+        },
+    },
+    {
+        name: 'agentdb_pattern_store_batch',
+        description: 'Batch store multiple reasoning patterns efficiently using transactions and parallel embedding generation. 4x faster than sequential agentdb_pattern_store calls. 🔄 PARALLEL-SAFE: Can be used alongside other batch operations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                patterns: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            taskType: { type: 'string', description: 'Type of task (e.g., "code_review", "data_analysis")' },
+                            approach: { type: 'string', description: 'Description of the reasoning approach' },
+                            successRate: { type: 'number', description: 'Success rate (0-1)' },
+                            tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags' },
+                            metadata: { type: 'object', description: 'Additional metadata' },
+                        },
+                        required: ['taskType', 'approach', 'successRate'],
+                    },
+                    description: 'Array of reasoning patterns to store',
+                    minItems: 1,
+                    maxItems: 500,
+                },
+                batch_size: { type: 'number', description: 'Batch size for processing (default: 50)', default: 50 },
+                format: {
+                    type: 'string',
+                    enum: ['concise', 'detailed', 'json'],
+                    description: 'Response format (default: concise)',
+                    default: 'concise',
+                },
+            },
+            required: ['patterns'],
+        },
+    },
 ];
 // ============================================================================
 // Tool Handlers
@@ -1103,6 +1221,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // ======================================================================
             case 'agentdb_stats': {
                 const detailed = args?.detailed || false;
+                // Check cache first (60s TTL)
+                const cacheKey = `stats:${detailed ? 'detailed' : 'summary'}`;
+                const cached = caches.stats.get(cacheKey);
+                if (cached) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `${cached}\n\n⚡ (cached)`,
+                            },
+                        ],
+                    };
+                }
                 // Helper to safely query table count
                 const safeCount = (tableName) => {
                     try {
@@ -1154,6 +1285,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         `   Database Size: ${totalMB} MB\n` +
                         `   Recent Activity (7d): ${recentActivity.count} episodes\n`;
                 }
+                // Cache the result (60s TTL)
+                caches.stats.set(cacheKey, output);
                 return {
                     content: [
                         {
@@ -1228,32 +1361,57 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'agentdb_pattern_stats': {
+                // Check cache first (60s TTL)
+                const cacheKey = 'pattern_stats';
+                const cached = caches.stats.get(cacheKey);
+                if (cached) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `${cached}\n\n⚡ (cached)`,
+                            },
+                        ],
+                    };
+                }
                 const stats = reasoningBank.getPatternStats();
+                const output = `📊 Reasoning Pattern Statistics\n\n` +
+                    `📈 Overview:\n` +
+                    `   Total Patterns: ${stats.totalPatterns}\n` +
+                    `   Avg Success Rate: ${(stats.avgSuccessRate * 100).toFixed(1)}%\n` +
+                    `   Avg Uses per Pattern: ${stats.avgUses.toFixed(1)}\n` +
+                    `   High Performing (≥80%): ${stats.highPerformingPatterns}\n` +
+                    `   Recent (7 days): ${stats.recentPatterns}\n\n` +
+                    `🏆 Top Task Types:\n` +
+                    stats.topTaskTypes.slice(0, 10).map((tt, i) => `   ${i + 1}. ${tt.taskType}: ${tt.count} patterns`).join('\n') +
+                    (stats.topTaskTypes.length === 0 ? '   No patterns stored yet' : '');
+                // Cache the result (60s TTL)
+                caches.stats.set(cacheKey, output);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `📊 Reasoning Pattern Statistics\n\n` +
-                                `📈 Overview:\n` +
-                                `   Total Patterns: ${stats.totalPatterns}\n` +
-                                `   Avg Success Rate: ${(stats.avgSuccessRate * 100).toFixed(1)}%\n` +
-                                `   Avg Uses per Pattern: ${stats.avgUses.toFixed(1)}\n` +
-                                `   High Performing (≥80%): ${stats.highPerformingPatterns}\n` +
-                                `   Recent (7 days): ${stats.recentPatterns}\n\n` +
-                                `🏆 Top Task Types:\n` +
-                                stats.topTaskTypes.slice(0, 10).map((tt, i) => `   ${i + 1}. ${tt.taskType}: ${tt.count} patterns`).join('\n') +
-                                (stats.topTaskTypes.length === 0 ? '   No patterns stored yet' : ''),
+                            text: output,
                         },
                     ],
                 };
             }
             case 'agentdb_clear_cache': {
                 const cacheType = args?.cache_type || 'all';
+                let cleared = 0;
                 switch (cacheType) {
                     case 'patterns':
+                        cleared += caches.patterns.clear();
+                        reasoningBank.clearCache();
+                        break;
                     case 'stats':
+                        cleared += caches.stats.clear();
+                        cleared += caches.metrics.clear();
+                        break;
                     case 'all':
+                        caches.clearAll();
                         reasoningBank.clearCache();
+                        cleared = -1; // All cleared
                         break;
                 }
                 return {
@@ -1262,12 +1420,317 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             type: 'text',
                             text: `✅ Cache cleared successfully!\n\n` +
                                 `🧹 Cache Type: ${cacheType}\n` +
-                                `♻️  Statistics and search results will be refreshed on next query`,
+                                `♻️  ${cleared === -1 ? 'All caches' : `${cleared} cache entries`} cleared\n` +
+                                `📊 Statistics and search results will be refreshed on next query`,
                         },
                     ],
                 };
             }
             // ======================================================================
+            // BATCH OPERATION TOOLS (v2.0 MCP Optimization - Phase 2)
+            // ======================================================================
+            case 'skill_create_batch': {
+                try {
+                    // Validate inputs
+                    const skillsArray = validateArrayLength(args?.skills, 'skills', 1, 100);
+                    const batchSize = args?.batch_size ? validateNumericRange(args.batch_size, 'batch_size', 1, 100) : 32;
+                    const format = args?.format ? validateEnum(args.format, 'format', ['concise', 'detailed', 'json']) : 'concise';
+                    // Validate each skill
+                    const validatedSkills = skillsArray.map((skill, index) => {
+                        const name = validateTaskString(skill.name, `skills[${index}].name`);
+                        const description = validateTaskString(skill.description, `skills[${index}].description`);
+                        const successRate = skill.success_rate !== undefined
+                            ? validateNumericRange(skill.success_rate, `skills[${index}].success_rate`, 0, 1)
+                            : 0.0;
+                        return {
+                            name,
+                            description,
+                            signature: skill.signature || { inputs: {}, outputs: {} },
+                            code: skill.code || '',
+                            successRate,
+                            uses: skill.uses || 0,
+                            avgReward: skill.avg_reward || 0.0,
+                            avgLatencyMs: skill.avg_latency_ms || 0.0,
+                            tags: skill.tags || [],
+                            metadata: skill.metadata || {},
+                        };
+                    });
+                    // Use BatchOperations for efficient insertion
+                    const startTime = Date.now();
+                    const batchOpsConfig = new BatchOperations(db, embeddingService, {
+                        batchSize,
+                        parallelism: 4,
+                    });
+                    const skillIds = await batchOpsConfig.insertSkills(validatedSkills);
+                    const duration = Date.now() - startTime;
+                    // Format response
+                    if (format === 'json') {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        success: true,
+                                        inserted: skillIds.length,
+                                        skill_ids: skillIds,
+                                        duration_ms: duration,
+                                        batch_size: batchSize,
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    else if (format === 'detailed') {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✅ Batch skill creation completed!\n\n` +
+                                        `📊 Performance:\n` +
+                                        `   • Skills Created: ${skillIds.length}\n` +
+                                        `   • Duration: ${duration}ms\n` +
+                                        `   • Throughput: ${(skillIds.length / (duration / 1000)).toFixed(1)} skills/sec\n` +
+                                        `   • Batch Size: ${batchSize}\n` +
+                                        `   • Parallelism: 4 workers\n\n` +
+                                        `🆔 Created Skill IDs:\n` +
+                                        skillIds.slice(0, 10).map((id, i) => `   ${i + 1}. Skill #${id}: ${validatedSkills[i].name}`).join('\n') +
+                                        (skillIds.length > 10 ? `\n   ... and ${skillIds.length - 10} more skills` : '') +
+                                        `\n\n🧠 All embeddings generated in parallel\n` +
+                                        `💾 Transaction committed successfully`,
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        // Concise format (default)
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✅ Created ${skillIds.length} skills in ${duration}ms (${(skillIds.length / (duration / 1000)).toFixed(1)} skills/sec)`,
+                                },
+                            ],
+                        };
+                    }
+                }
+                catch (error) {
+                    const safeMessage = handleSecurityError(error);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Batch skill creation failed: ${safeMessage}\n\n` +
+                                    `💡 Troubleshooting:\n` +
+                                    `   • Ensure all skills have unique names\n` +
+                                    `   • Verify success_rate is between 0 and 1\n` +
+                                    `   • Check that skills array has 1-100 items\n` +
+                                    `   • Ensure descriptions are not empty`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            }
+            case 'reflexion_store_batch': {
+                try {
+                    // Validate inputs
+                    const episodesArray = validateArrayLength(args?.episodes, 'episodes', 1, 1000);
+                    const batchSize = args?.batch_size ? validateNumericRange(args.batch_size, 'batch_size', 1, 1000) : 100;
+                    const format = args?.format ? validateEnum(args.format, 'format', ['concise', 'detailed', 'json']) : 'concise';
+                    // Validate each episode
+                    const validatedEpisodes = episodesArray.map((ep, index) => {
+                        const sessionId = validateSessionId(ep.session_id);
+                        const task = validateTaskString(ep.task, `episodes[${index}].task`);
+                        const reward = validateNumericRange(ep.reward, `episodes[${index}].reward`, 0, 1);
+                        const success = validateBoolean(ep.success, `episodes[${index}].success`);
+                        return {
+                            sessionId,
+                            task,
+                            reward,
+                            success,
+                            critique: ep.critique || '',
+                            input: ep.input || '',
+                            output: ep.output || '',
+                            latencyMs: ep.latency_ms || 0,
+                            tokensUsed: ep.tokens || 0,
+                            tags: ep.tags || [],
+                            metadata: ep.metadata || {},
+                        };
+                    });
+                    // Use BatchOperations for efficient insertion
+                    const startTime = Date.now();
+                    const batchOpsConfig = new BatchOperations(db, embeddingService, {
+                        batchSize,
+                        parallelism: 4,
+                    });
+                    const insertedCount = await batchOpsConfig.insertEpisodes(validatedEpisodes);
+                    const duration = Date.now() - startTime;
+                    // Format response
+                    if (format === 'json') {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        success: true,
+                                        inserted: insertedCount,
+                                        duration_ms: duration,
+                                        batch_size: batchSize,
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    else if (format === 'detailed') {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✅ Batch episode storage completed!\n\n` +
+                                        `📊 Performance:\n` +
+                                        `   • Episodes Stored: ${insertedCount}\n` +
+                                        `   • Duration: ${duration}ms\n` +
+                                        `   • Throughput: ${(insertedCount / (duration / 1000)).toFixed(1)} episodes/sec\n` +
+                                        `   • Batch Size: ${batchSize}\n` +
+                                        `   • Parallelism: 4 workers\n\n` +
+                                        `📈 Statistics:\n` +
+                                        `   • Sessions: ${new Set(validatedEpisodes.map(e => e.sessionId)).size}\n` +
+                                        `   • Success Rate: ${(validatedEpisodes.filter(e => e.success).length / validatedEpisodes.length * 100).toFixed(1)}%\n` +
+                                        `   • Avg Reward: ${(validatedEpisodes.reduce((sum, e) => sum + e.reward, 0) / validatedEpisodes.length).toFixed(3)}\n\n` +
+                                        `🧠 All embeddings generated in parallel\n` +
+                                        `💾 Transaction committed successfully`,
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        // Concise format (default)
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✅ Stored ${insertedCount} episodes in ${duration}ms (${(insertedCount / (duration / 1000)).toFixed(1)} episodes/sec)`,
+                                },
+                            ],
+                        };
+                    }
+                }
+                catch (error) {
+                    const safeMessage = handleSecurityError(error);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Batch episode storage failed: ${safeMessage}\n\n` +
+                                    `💡 Troubleshooting:\n` +
+                                    `   • Ensure all session_ids are valid (alphanumeric, hyphens, underscores)\n` +
+                                    `   • Verify rewards are between 0 and 1\n` +
+                                    `   • Check that episodes array has 1-1000 items\n` +
+                                    `   • Ensure tasks are not empty or excessively long`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            }
+            case 'agentdb_pattern_store_batch': {
+                try {
+                    // Validate inputs
+                    const patternsArray = validateArrayLength(args?.patterns, 'patterns', 1, 500);
+                    const batchSize = args?.batch_size ? validateNumericRange(args.batch_size, 'batch_size', 1, 500) : 50;
+                    const format = args?.format ? validateEnum(args.format, 'format', ['concise', 'detailed', 'json']) : 'concise';
+                    // Validate each pattern
+                    const validatedPatterns = patternsArray.map((pattern, index) => {
+                        const taskType = validateTaskString(pattern.taskType, `patterns[${index}].taskType`);
+                        const approach = validateTaskString(pattern.approach, `patterns[${index}].approach`);
+                        const successRate = validateNumericRange(pattern.successRate, `patterns[${index}].successRate`, 0, 1);
+                        return {
+                            taskType,
+                            approach,
+                            successRate,
+                            tags: pattern.tags || [],
+                            metadata: pattern.metadata || {},
+                        };
+                    });
+                    // Use BatchOperations for efficient insertion
+                    const startTime = Date.now();
+                    const batchOpsConfig = new BatchOperations(db, embeddingService, {
+                        batchSize,
+                        parallelism: 4,
+                    });
+                    const patternIds = await batchOpsConfig.insertPatterns(validatedPatterns);
+                    const duration = Date.now() - startTime;
+                    // Format response
+                    if (format === 'json') {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        success: true,
+                                        inserted: patternIds.length,
+                                        pattern_ids: patternIds,
+                                        duration_ms: duration,
+                                        batch_size: batchSize,
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    else if (format === 'detailed') {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✅ Batch pattern storage completed!\n\n` +
+                                        `📊 Performance:\n` +
+                                        `   • Patterns Stored: ${patternIds.length}\n` +
+                                        `   • Duration: ${duration}ms\n` +
+                                        `   • Throughput: ${(patternIds.length / (duration / 1000)).toFixed(1)} patterns/sec\n` +
+                                        `   • Batch Size: ${batchSize}\n` +
+                                        `   • Parallelism: 4 workers\n\n` +
+                                        `📈 Statistics:\n` +
+                                        `   • Task Types: ${new Set(validatedPatterns.map(p => p.taskType)).size}\n` +
+                                        `   • Avg Success Rate: ${(validatedPatterns.reduce((sum, p) => sum + p.successRate, 0) / validatedPatterns.length * 100).toFixed(1)}%\n` +
+                                        `   • High Performing (≥80%): ${validatedPatterns.filter(p => p.successRate >= 0.8).length}\n\n` +
+                                        `🆔 Sample Pattern IDs: ${patternIds.slice(0, 5).join(', ')}${patternIds.length > 5 ? '...' : ''}\n` +
+                                        `🧠 All embeddings generated in parallel\n` +
+                                        `💾 Transaction committed successfully`,
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        // Concise format (default)
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `✅ Stored ${patternIds.length} patterns in ${duration}ms (${(patternIds.length / (duration / 1000)).toFixed(1)} patterns/sec)`,
+                                },
+                            ],
+                        };
+                    }
+                }
+                catch (error) {
+                    const safeMessage = handleSecurityError(error);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Batch pattern storage failed: ${safeMessage}\n\n` +
+                                    `💡 Troubleshooting:\n` +
+                                    `   • Ensure taskType and approach are not empty\n` +
+                                    `   • Verify successRate is between 0 and 1\n` +
+                                    `   • Check that patterns array has 1-500 items\n` +
+                                    `   • Avoid excessively long task types or approaches`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            }
+            // ======================================================================
             // LEARNING SYSTEM TOOLS (Tools 1-5)
             // ======================================================================
             case 'learning_start_session': {
@@ -1397,33 +1860,49 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const timeWindowDays = args?.time_window_days || 7;
                 const includeTrends = args?.include_trends !== false;
                 const groupBy = args?.group_by || 'task';
+                // Check cache first (120s TTL for expensive computations)
+                const cacheKey = `metrics:${sessionId || 'all'}:${timeWindowDays}:${groupBy}:${includeTrends}`;
+                const cached = caches.metrics.get(cacheKey);
+                if (cached) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `${cached}\n\n⚡ (cached)`,
+                            },
+                        ],
+                    };
+                }
                 const metrics = await learningSystem.getMetrics({
                     sessionId,
                     timeWindowDays,
                     includeTrends,
                     groupBy,
                 });
+                const output = `📊 Learning Performance Metrics\n\n` +
+                    `⏱️  Time Window: ${timeWindowDays} days\n\n` +
+                    `📈 Overall Performance:\n` +
+                    `   • Total Episodes: ${metrics.overall.totalEpisodes}\n` +
+                    `   • Success Rate: ${(metrics.overall.successRate * 100).toFixed(1)}%\n` +
+                    `   • Avg Reward: ${metrics.overall.avgReward.toFixed(3)}\n` +
+                    `   • Reward Range: [${metrics.overall.minReward.toFixed(2)}, ${metrics.overall.maxReward.toFixed(2)}]\n` +
+                    `   • Avg Latency: ${metrics.overall.avgLatencyMs.toFixed(0)}ms\n\n` +
+                    `🎯 Top ${groupBy.charAt(0).toUpperCase() + groupBy.slice(1)}s:\n` +
+                    metrics.groupedMetrics.slice(0, 5).map((g, i) => `   ${i + 1}. ${g.key.substring(0, 40)}${g.key.length > 40 ? '...' : ''}\n` +
+                        `      Count: ${g.count}, Success: ${(g.successRate * 100).toFixed(1)}%, Reward: ${g.avgReward.toFixed(2)}`).join('\n') +
+                    (metrics.groupedMetrics.length === 0 ? '   No data available' : '') +
+                    (includeTrends && metrics.trends.length > 0 ? `\n\n📉 Recent Trends (last ${Math.min(7, metrics.trends.length)} days):\n` +
+                        metrics.trends.slice(-7).map((t) => `   ${t.date}: ${t.count} episodes, ${(t.successRate * 100).toFixed(1)}% success`).join('\n') : '') +
+                    (metrics.policyImprovement.versions > 0 ? `\n\n🧠 Policy Improvement:\n` +
+                        `   • Versions: ${metrics.policyImprovement.versions}\n` +
+                        `   • Q-Value Improvement: ${metrics.policyImprovement.qValueImprovement >= 0 ? '+' : ''}${metrics.policyImprovement.qValueImprovement.toFixed(3)}` : '');
+                // Cache the result (120s TTL)
+                caches.metrics.set(cacheKey, output);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `📊 Learning Performance Metrics\n\n` +
-                                `⏱️  Time Window: ${timeWindowDays} days\n\n` +
-                                `📈 Overall Performance:\n` +
-                                `   • Total Episodes: ${metrics.overall.totalEpisodes}\n` +
-                                `   • Success Rate: ${(metrics.overall.successRate * 100).toFixed(1)}%\n` +
-                                `   • Avg Reward: ${metrics.overall.avgReward.toFixed(3)}\n` +
-                                `   • Reward Range: [${metrics.overall.minReward.toFixed(2)}, ${metrics.overall.maxReward.toFixed(2)}]\n` +
-                                `   • Avg Latency: ${metrics.overall.avgLatencyMs.toFixed(0)}ms\n\n` +
-                                `🎯 Top ${groupBy.charAt(0).toUpperCase() + groupBy.slice(1)}s:\n` +
-                                metrics.groupedMetrics.slice(0, 5).map((g, i) => `   ${i + 1}. ${g.key.substring(0, 40)}${g.key.length > 40 ? '...' : ''}\n` +
-                                    `      Count: ${g.count}, Success: ${(g.successRate * 100).toFixed(1)}%, Reward: ${g.avgReward.toFixed(2)}`).join('\n') +
-                                (metrics.groupedMetrics.length === 0 ? '   No data available' : '') +
-                                (includeTrends && metrics.trends.length > 0 ? `\n\n📉 Recent Trends (last ${Math.min(7, metrics.trends.length)} days):\n` +
-                                    metrics.trends.slice(-7).map((t) => `   ${t.date}: ${t.count} episodes, ${(t.successRate * 100).toFixed(1)}% success`).join('\n') : '') +
-                                (metrics.policyImprovement.versions > 0 ? `\n\n🧠 Policy Improvement:\n` +
-                                    `   • Versions: ${metrics.policyImprovement.versions}\n` +
-                                    `   • Q-Value Improvement: ${metrics.policyImprovement.qValueImprovement >= 0 ? '+' : ''}${metrics.policyImprovement.qValueImprovement.toFixed(3)}` : ''),
+                            text: output,
                         },
                     ],
                 };
@@ -1607,12 +2086,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('🚀 AgentDB MCP Server v1.3.0 running on stdio');
-    console.error('📦 29 tools available (5 core vector DB + 9 frontier + 10 learning + 5 AgentDB tools)');
+    console.error('🚀 AgentDB MCP Server v2.0.0 running on stdio');
+    console.error('📦 32 tools available (5 core + 9 frontier + 10 learning + 5 AgentDB + 3 batch ops)');
     console.error('🧠 Embedding service initialized');
     console.error('🎓 Learning system ready (9 RL algorithms)');
-    console.error('✨ New learning tools: metrics, transfer, explain, experience_record, reward_signal');
-    console.error('🔬 Extended features: transfer learning, XAI explanations, reward shaping');
+    console.error('⚡ NEW v2.0: Batch operations (3-4x faster), format parameters, enhanced validation');
+    console.error('🔬 Features: transfer learning, XAI explanations, reward shaping, intelligent caching');
     // Keep the process alive - the StdioServerTransport handles stdin/stdout
     // but we need to ensure Node.js doesn't exit when main() completes
     // Use setInterval to keep event loop alive (like many MCP servers do)