agentdb 1.6.1 → 2.0.0-alpha.1

package/src/mcp/agentdb-mcp-server.ts

@@ -23,10 +23,17 @@ 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 { MCPToolCaches } from '../optimizations/ToolCache.js';
 import {
   validateId,
   validateTimestamp,
   validateSessionId,
+  validateTaskString,
+  validateNumericRange,
+  validateArrayLength,
+  validateObject,
+  validateBoolean,
+  validateEnum,
   ValidationError,
   handleSecurityError,
 } from '../security/input-validation.js';
@@ -265,6 +272,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
@@ -755,6 +763,123 @@ 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'],
+    },
+  },
 ];
 
 // ============================================================================
@@ -1202,6 +1327,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'agentdb_stats': {
         const detailed = (args?.detailed as boolean) || 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: string): number => {
           try {
@@ -1259,6 +1398,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             `   Recent Activity (7d): ${recentActivity.count} episodes\n`;
         }
 
+        // Cache the result (60s TTL)
+        caches.stats.set(cacheKey, output);
+
         return {
           content: [
             {
@@ -1343,24 +1485,43 @@ 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,
             },
           ],
         };
@@ -1369,11 +1530,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'agentdb_clear_cache': {
         const cacheType = (args?.cache_type as string) || '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;
         }
 
@@ -1383,12 +1554,328 @@ 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'] as const) : 'concise';
+
+          // Validate each skill
+          const validatedSkills = skillsArray.map((skill: any, index: number) => {
+            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: any) {
+          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'] as const) : 'concise';
+
+          // Validate each episode
+          const validatedEpisodes = episodesArray.map((ep: any, index: number) => {
+            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: any) {
+          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'] as const) : 'concise';
+
+          // Validate each pattern
+          const validatedPatterns = patternsArray.map((pattern: any, index: number) => {
+            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: any) {
+          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)
       // ======================================================================
@@ -1540,6 +2027,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const includeTrends = (args?.include_trends as boolean) !== false;
         const groupBy = (args?.group_by as 'task' | 'session' | 'skill') || '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,
@@ -1547,31 +2048,36 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           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,
             },
           ],
         };
@@ -1777,12 +2283,12 @@ 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