agentic-flow 1.6.4 → 1.6.5

package/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.6.5] - 2025-10-18
+
+### Changed
+
+- **AgentDB Dependency** - Updated to use published npm package instead of local file reference
+  - Changed from `"agentdb": "file:../packages/agentdb"` to `"agentdb": "^1.0.4"`
+  - Now uses stable published version from npm registry
+  - Includes all 20 MCP tools (10 core AgentDB + 10 learning tools)
+  - Easier installation and dependency management for end users
+
+### Added
+
+- **AgentDB v1.0.4 Integration** - Complete MCP learning system now available
+  - 10 learning tools: learning_start_session, learning_end_session, learning_predict, learning_feedback, learning_train, learning_metrics, learning_transfer, learning_explain, experience_record, reward_signal
+  - Q-learning with epsilon-greedy exploration
+  - Multi-dimensional reward system (success 40%, efficiency 30%, quality 20%, cost 10%)
+  - Experience replay buffer with prioritized sampling
+  - Transfer learning between similar tasks
+  - Session management with state persistence
+
 ## [1.6.4] - 2025-10-16
 
 ### 🚀 QUIC Transport - Production Ready (100% Complete)

package/dist/cli-proxy.js

@@ -31,6 +31,7 @@ import { parseArgs } from "./utils/cli.js";
 import { getAgent, listAgents } from "./utils/agentLoader.js";
 import { claudeAgent } from "./agents/claudeAgent.js";
 import { handleReasoningBankCommand } from "./utils/reasoningbankCommands.js";
+import { handleAgentDBCommand } from "./utils/agentdbCommands.js";
 import { handleConfigCommand } from "./cli/config-wizard.js";
 import { handleAgentCommand } from "./cli/agent-manager.js";
 import { ModelOptimizer } from "./utils/modelOptimizer.js";
@@ -43,8 +44,6 @@ const VERSION = packageJson.version;
 class AgenticFlowCLI {
     proxyServer = null;
     proxyPort = 3000;
-    quicProxyProcess = null;
-    quicProxyPort = 4433;
     async start() {
         const options = parseArgs();
         if (options.version) {
@@ -56,7 +55,7 @@ class AgenticFlowCLI {
             process.exit(0);
         }
         // If no mode and no agent specified, show help
-        if (!options.agent && options.mode !== 'list' && !['config', 'agent-manager', 'mcp-manager', 'proxy', 'quic', 'claude-code', 'mcp', 'reasoningbank'].includes(options.mode)) {
+        if (!options.agent && options.mode !== 'list' && !['config', 'agent-manager', 'mcp-manager', 'agentdb', 'proxy', 'quic', 'claude-code', 'mcp', 'reasoningbank'].includes(options.mode)) {
             this.printHelp();
             process.exit(0);
         }
@@ -76,6 +75,12 @@ class AgenticFlowCLI {
             await handleAgentCommand(agentArgs);
             process.exit(0);
         }
+        if (options.mode === 'agentdb') {
+            // Handle AgentDB commands
+            const agentdbArgs = process.argv.slice(3); // Skip 'node', 'cli-proxy.js', 'agentdb'
+            await handleAgentDBCommand(agentdbArgs);
+            process.exit(0);
+        }
         if (options.mode === 'mcp-manager') {
             // Handle MCP manager commands (add, list, remove, etc.)
             const { spawn } = await import('child_process');
@@ -187,11 +192,6 @@ class AgenticFlowCLI {
             console.log(`  ANTHROPIC_API_KEY: ${process.env.ANTHROPIC_API_KEY ? '✓ set' : '✗ not set'}\n`);
         }
         try {
-            // Start QUIC proxy if transport is set to quic
-            if (options.transport === 'quic') {
-                console.log('🚀 Initializing QUIC transport proxy...');
-                await this.startQuicProxyBackground();
-            }
             // Start proxy if needed (ONNX, OpenRouter, Gemini, or Requesty)
             if (useONNX) {
                 console.log('🚀 Initializing ONNX local inference proxy...');
@@ -215,19 +215,11 @@ class AgenticFlowCLI {
             // Run agent
             await this.runAgent(options, useOpenRouter, useGemini, useONNX, useRequesty);
             logger.info('Execution completed successfully');
-            // Cleanup QUIC proxy if it was started
-            if (this.quicProxyProcess) {
-                this.quicProxyProcess.kill();
-            }
             process.exit(0);
         }
         catch (err) {
             logger.error('Execution failed', { error: err });
             console.error(err);
-            // Cleanup QUIC proxy if it was started
-            if (this.quicProxyProcess) {
-                this.quicProxyProcess.kill();
-            }
             process.exit(1);
         }
     }
@@ -725,40 +717,6 @@ PERFORMANCE:
   • Survives network changes (WiFi ↔ cellular)
 `);
     }
-    async startQuicProxyBackground() {
-        const { spawn } = await import('child_process');
-        const { resolve } = await import('path');
-        const quicProxyPath = resolve(__dirname, './proxy/quic-proxy.js');
-        const port = parseInt(process.env.QUIC_PORT || '4433');
-        this.quicProxyPort = port;
-        const env = { ...process.env };
-        env.QUIC_PORT = port.toString();
-        console.log(`🔧 Transport: QUIC (UDP port ${port})`);
-        console.log(`⚡ 0-RTT enabled, 100+ streams`);
-        console.log(`🔐 TLS 1.3 encrypted by default\n`);
-        this.quicProxyProcess = spawn('node', [quicProxyPath], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: env,
-            detached: false
-        });
-        // Capture output for debugging
-        if (process.env.VERBOSE === 'true') {
-            this.quicProxyProcess.stdout?.on('data', (data) => {
-                console.log(`[QUIC] ${data.toString().trim()}`);
-            });
-            this.quicProxyProcess.stderr?.on('data', (data) => {
-                console.error(`[QUIC Error] ${data.toString().trim()}`);
-            });
-        }
-        this.quicProxyProcess.on('error', (err) => {
-            logger.error('QUIC proxy failed to start', { error: err });
-        });
-        // Set ANTHROPIC_BASE_URL to use QUIC proxy
-        process.env.ANTHROPIC_BASE_URL = `http://localhost:${port}`;
-        // Wait for QUIC proxy to be ready
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        console.log(`✅ QUIC proxy ready on UDP port ${port}\n`);
-    }
     async runAgent(options, useOpenRouter, useGemini, useONNX = false, useRequesty = false) {
         const agentName = options.agent || process.env.AGENT || '';
         const task = options.task || process.env.TASK || '';
@@ -824,15 +782,6 @@ PERFORMANCE:
         console.log(`\n🤖 Agent: ${agent.name}`);
         console.log(`📝 Description: ${agent.description}\n`);
         console.log(`🎯 Task: ${task}\n`);
-        // Display transport information if QUIC is enabled
-        if (options.transport === 'quic') {
-            console.log(`🚀 Transport: QUIC (UDP)`);
-            console.log(`⚡ Performance: 50-70% faster than HTTP/2`);
-            console.log(`🔐 Security: TLS 1.3 encrypted\n`);
-        }
-        else if (options.transport === 'http2') {
-            console.log(`🚀 Transport: HTTP/2 (TCP)\n`);
-        }
         if (useOpenRouter) {
             const model = options.model || process.env.COMPLETION_MODEL || 'deepseek/deepseek-chat';
             console.log(`🔧 Provider: OpenRouter (via proxy)`);
@@ -950,6 +899,7 @@ COMMANDS:
   config [subcommand]     Manage environment configuration (interactive wizard)
   mcp <command> [server]  Manage MCP servers (start, stop, status, list)
   agent <command>         Agent management (list, create, info, conflicts)
+  agentdb <command>       AgentDB vector database management (init, search, migrate, etc.)
   proxy [options]         Run standalone proxy server for Claude Code/Cursor
   quic [options]          Run QUIC transport proxy for ultra-low latency (50-70% faster)
   claude-code [options]   Spawn Claude Code with auto-configured proxy
@@ -978,6 +928,21 @@ AGENT COMMANDS:
   npx agentic-flow agent info <name>     Show detailed agent information
   npx agentic-flow agent conflicts       Check for package/local conflicts
 
+AGENTDB COMMANDS (Vector Database for ReasoningBank):
+  npx agentic-flow agentdb init          Initialize AgentDB database
+  npx agentic-flow agentdb search        Search similar patterns (vector similarity)
+  npx agentic-flow agentdb insert        Insert pattern with embedding
+  npx agentic-flow agentdb train         Train learning model on experiences
+  npx agentic-flow agentdb stats         Display database statistics
+  npx agentic-flow agentdb optimize      Optimize database (consolidation, pruning)
+  npx agentic-flow agentdb migrate       Migrate from legacy ReasoningBank
+  npx agentic-flow agentdb export        Export patterns to JSON
+  npx agentic-flow agentdb import        Import patterns from JSON
+  npx agentic-flow agentdb help          Show detailed AgentDB help
+
+  Performance: 150x-12,500x faster than legacy ReasoningBank
+  Features: HNSW indexing, learning plugins, reasoning agents, QUIC sync
+
 OPTIONS:
   --task, -t <task>           Task description for agent mode
   --model, -m <model>         Model to use (triggers OpenRouter if contains "/")
@@ -1030,11 +995,6 @@ EXAMPLES:
   npx agentic-flow proxy --provider openrouter --port 3000
   npx agentic-flow proxy --provider gemini --port 3001
 
-  # QUIC Transport (Ultra-fast agent communication)
-  npx agentic-flow --agent coder --task "Build API" --transport quic
-  npx agentic-flow --agent reviewer --task "Code review" --transport quic --provider openrouter
-  export AGENTIC_FLOW_TRANSPORT=quic  # Set default transport
-
   # QUIC Transport (Ultra-low latency, 50-70% faster than TCP)
   npx agentic-flow quic --port 4433                    # Start QUIC server
   npx agentic-flow quic --cert ./certs/cert.pem --key ./certs/key.pem
@@ -1060,18 +1020,17 @@ EXAMPLES:
   npx agentic-flow --agent coder --task "Simple function" --optimize --max-cost 0.001
 
 ENVIRONMENT VARIABLES:
-  ANTHROPIC_API_KEY           Anthropic API key (for Claude models)
-  OPENROUTER_API_KEY          OpenRouter API key (for alternative models)
-  GOOGLE_GEMINI_API_KEY       Google Gemini API key (for Gemini models)
-  USE_OPENROUTER              Set to 'true' to force OpenRouter usage
-  USE_GEMINI                  Set to 'true' to force Gemini usage
-  COMPLETION_MODEL            Default model for OpenRouter
-  AGENTS_DIR                  Path to agents directory
-  PROXY_PORT                  Proxy server port (default: 3000)
-  QUIC_PORT                   QUIC transport port (default: 4433)
-  QUIC_CERT_PATH              Path to TLS certificate for QUIC
-  QUIC_KEY_PATH               Path to TLS private key for QUIC
-  AGENTIC_FLOW_TRANSPORT      Transport layer (quic, http2, auto)
+  ANTHROPIC_API_KEY       Anthropic API key (for Claude models)
+  OPENROUTER_API_KEY      OpenRouter API key (for alternative models)
+  GOOGLE_GEMINI_API_KEY   Google Gemini API key (for Gemini models)
+  USE_OPENROUTER          Set to 'true' to force OpenRouter usage
+  USE_GEMINI              Set to 'true' to force Gemini usage
+  COMPLETION_MODEL        Default model for OpenRouter
+  AGENTS_DIR              Path to agents directory
+  PROXY_PORT              Proxy server port (default: 3000)
+  QUIC_PORT               QUIC transport port (default: 4433)
+  QUIC_CERT_PATH          Path to TLS certificate for QUIC
+  QUIC_KEY_PATH           Path to TLS private key for QUIC
 
 OPENROUTER MODELS (Best Free Tested):
   ✅ deepseek/deepseek-r1-0528:free           (reasoning, 95s/task, RFC validation)
@@ -1082,11 +1041,12 @@ OPENROUTER MODELS (Best Free Tested):
   All models above support OpenRouter leaderboard tracking via HTTP-Referer headers.
   See https://openrouter.ai/models for full model catalog.
 
-MCP TOOLS (213+ available):
+MCP TOOLS (223+ available):
   • agentic-flow: 7 tools (agent execution, creation, management, model optimization)
   • claude-flow: 101 tools (neural networks, GitHub, workflows, DAA)
   • flow-nexus: 96 cloud tools (sandboxes, distributed swarms, templates)
   • agentic-payments: 6 tools (payment authorization, multi-agent consensus)
+  • agentdb: 10 tools (vector search, learning, reasoning, optimization)
 
 OPTIMIZATION BENEFITS:
   💰 Cost Savings: 85-98% cheaper models for same quality tasks

package/dist/mcp/fastmcp/tools/swarm/init.js

@@ -3,10 +3,10 @@ import { z } from 'zod';
 import { execSync } from 'child_process';
 export const swarmInitTool = {
     name: 'swarm_init',
-    description: 'Initialize a multi-agent swarm with specified topology and transport protocol (QUIC or HTTP/2)',
+    description: 'Initialize a multi-agent swarm with specified topology',
     parameters: z.object({
         topology: z.enum(['mesh', 'hierarchical', 'ring', 'star'])
-            .describe('Swarm topology: mesh (peer-to-peer), hierarchical (coordinator-worker), ring (circular), star (centralized)'),
+            .describe('Swarm topology'),
         maxAgents: z.number()
             .positive()
             .optional()
@@ -15,22 +15,11 @@ export const swarmInitTool = {
         strategy: z.enum(['balanced', 'specialized', 'adaptive'])
             .optional()
             .default('balanced')
-            .describe('Agent distribution strategy'),
-        transport: z.enum(['quic', 'http2', 'auto'])
-            .optional()
-            .default('auto')
-            .describe('Transport protocol: quic (fastest, 0-RTT), http2 (fallback), auto (automatic selection)'),
-        quicPort: z.number()
-            .positive()
-            .optional()
-            .default(4433)
-            .describe('QUIC server port (default: 4433)')
+            .describe('Agent distribution strategy')
     }),
-    execute: async ({ topology, maxAgents, strategy, transport, quicPort }, { onProgress, auth }) => {
+    execute: async ({ topology, maxAgents, strategy }, { onProgress, auth }) => {
         try {
-            const transportFlag = transport ? ` --transport ${transport}` : '';
-            const portFlag = quicPort !== 4433 ? ` --quic-port ${quicPort}` : '';
-            const cmd = `npx claude-flow@alpha swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}${transportFlag}${portFlag}`;
+            const cmd = `npx claude-flow@alpha swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}`;
             const result = execSync(cmd, {
                 encoding: 'utf-8',
                 maxBuffer: 10 * 1024 * 1024
@@ -40,8 +29,6 @@ export const swarmInitTool = {
                 topology,
                 maxAgents,
                 strategy,
-                transport: transport || 'auto',
-                quicPort,
                 result: result.trim(),
                 userId: auth?.userId,
                 timestamp: new Date().toISOString()

package/dist/reasoningbank/agentdb-adapter.js

@@ -0,0 +1,125 @@
+/**
+ * AgentDB Adapter for ReasoningBank
+ *
+ * This module integrates the AgentDB vector database as a drop-in replacement
+ * for the legacy ReasoningBank implementation.
+ *
+ * Features:
+ * - 150x-12,500x faster than legacy implementation
+ * - HNSW vector indexing for O(log n) search
+ * - Learning plugins (Decision Transformer, Q-Learning, etc.)
+ * - Reasoning agents (Pattern Matching, Context Synthesis, etc.)
+ * - QUIC synchronization for multi-agent coordination
+ * - 100% backward compatible API
+ */
+/**
+ * Create AgentDB ReasoningBank adapter
+ *
+ * @param config - Configuration options
+ * @returns Initialized AgentDB adapter
+ *
+ * @example
+ * ```typescript
+ * import { createAgentDBAdapter } from 'agentic-flow/reasoningbank/agentdb';
+ *
+ * const adapter = await createAgentDBAdapter({
+ *   dbPath: '.agentdb/reasoningbank.db',
+ *   enableLearning: true,
+ *   enableReasoning: true,
+ * });
+ *
+ * // Insert pattern
+ * const id = await adapter.insertPattern({
+ *   id: '',
+ *   type: 'pattern',
+ *   domain: 'example',
+ *   pattern_data: JSON.stringify({
+ *     embedding: [0.1, 0.2, ...],
+ *     pattern: { code: 'example' }
+ *   }),
+ *   confidence: 0.9,
+ *   usage_count: 0,
+ *   success_count: 0,
+ *   created_at: Date.now(),
+ *   last_used: Date.now(),
+ * });
+ *
+ * // Retrieve with reasoning
+ * const result = await adapter.retrieveWithReasoning(queryEmbedding, {
+ *   domain: 'example',
+ *   synthesizeContext: true,
+ *   k: 10,
+ * });
+ * ```
+ */
+export async function createAgentDBAdapter(config) {
+    // Dynamic import to avoid loading AgentDB unless explicitly used
+    const { AgentDBReasoningBankAdapter } = await import('agentdb/reasoningbank/adapter/agentdb-adapter');
+    const adapter = new AgentDBReasoningBankAdapter({
+        dbPath: config?.dbPath || '.agentdb/reasoningbank.db',
+        enableLearning: config?.enableLearning ?? true,
+        enableReasoning: config?.enableReasoning ?? true,
+        enableQUICSync: config?.enableQUICSync ?? false,
+        quantizationType: config?.quantizationType || 'scalar',
+        cacheSize: config?.cacheSize || 1000,
+        syncPort: config?.syncPort || 4433,
+        syncPeers: config?.syncPeers || [],
+    });
+    await adapter.initialize();
+    return adapter;
+}
+/**
+ * Create AgentDB adapter with default configuration
+ *
+ * @example
+ * ```typescript
+ * import { createDefaultAgentDBAdapter } from 'agentic-flow/reasoningbank/agentdb';
+ *
+ * const adapter = await createDefaultAgentDBAdapter();
+ * ```
+ */
+export async function createDefaultAgentDBAdapter() {
+    return createAgentDBAdapter({
+        dbPath: '.agentdb/reasoningbank.db',
+        enableLearning: true,
+        enableReasoning: true,
+        enableQUICSync: false,
+        quantizationType: 'scalar',
+        cacheSize: 1000,
+    });
+}
+/**
+ * Migrate from legacy ReasoningBank to AgentDB
+ *
+ * @param sourcePath - Path to legacy database
+ * @param destinationPath - Path for AgentDB database
+ * @returns Migration result with statistics
+ *
+ * @example
+ * ```typescript
+ * import { migrateToAgentDB } from 'agentic-flow/reasoningbank/agentdb';
+ *
+ * const result = await migrateToAgentDB(
+ *   '.swarm/memory.db',
+ *   '.agentdb/reasoningbank.db'
+ * );
+ *
+ * console.log(`Migrated ${result.patternsMigrated} patterns`);
+ * console.log(`Backup: ${result.backupPath}`);
+ * ```
+ */
+export async function migrateToAgentDB(sourcePath, destinationPath) {
+    const { migrateLegacyDatabase } = await import('agentdb/reasoningbank/migration/migrate');
+    return migrateLegacyDatabase(sourcePath, destinationPath || '.agentdb/reasoningbank.db');
+}
+/**
+ * Validate migration from legacy to AgentDB
+ *
+ * @param sourcePath - Path to legacy database
+ * @param destinationPath - Path to AgentDB database
+ * @returns Validation result
+ */
+export async function validateMigration(sourcePath, destinationPath) {
+    const { validateMigration: validate } = await import('agentdb/reasoningbank/migration/migrate');
+    return validate(sourcePath, destinationPath);
+}

package/dist/reasoningbank/index.js

@@ -99,6 +99,10 @@ export async function runTask(options) {
         consolidated
     };
 }
+// AgentDB Integration
+// Ultra-fast vector database drop-in replacement
+// 150x-12,500x faster than legacy implementation
+export { createAgentDBAdapter, createDefaultAgentDBAdapter, migrateToAgentDB, validateMigration } from './agentdb-adapter.js';
 // Version info
 export const VERSION = '1.0.0';
 export const PAPER_URL = 'https://arxiv.org/html/2509.25140v1';