@duckmind/deepquark-darwin-arm64 0.9.83 → 0.9.90

package/.deepquark/skills/bundled/knowledge-graph/server/test-mcp-session.ts

@@ -0,0 +1,127 @@
+#!/usr/bin/env bun
+/**
+ * MCP Knowledge System Test with proper session handling
+ */
+
+const MCP_URL = 'http://localhost:8000/mcp';
+
+async function initSession(): Promise<string | null> {
+  const res = await fetch(MCP_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'initialize',
+      params: {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'bun-test', version: '1.0' },
+      },
+    }),
+  });
+
+  // Get session ID from header or response
+  const sessionId = res.headers.get('mcp-session-id') || res.headers.get('x-session-id');
+  const text = await res.text();
+  console.log('Init response:', text.slice(0, 200));
+  console.log('Headers:', Object.fromEntries(res.headers.entries()));
+  return sessionId;
+}
+
+async function callTool(sessionId: string | null, tool: string, args: any) {
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  if (sessionId) {
+    headers['mcp-session-id'] = sessionId;
+    headers['x-session-id'] = sessionId;
+  }
+
+  const start = Date.now();
+  const res = await fetch(MCP_URL, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method: 'tools/call',
+      params: { name: tool, arguments: args },
+    }),
+  });
+
+  const text = await res.text();
+  const duration = Date.now() - start;
+
+  // Parse result
+  let result: any = null;
+  for (const line of text.split('\n')) {
+    if (line.startsWith('data: ')) {
+      try {
+        const data = JSON.parse(line.slice(6));
+        if (data.result) result = data.result;
+      } catch {}
+    }
+  }
+
+  // Also try direct JSON
+  if (!result) {
+    try {
+      const json = JSON.parse(text);
+      result = json.result || json;
+    } catch {}
+  }
+
+  return { result, duration, raw: text, headers: Object.fromEntries(res.headers.entries()) };
+}
+
+async function main() {
+  console.log('═'.repeat(60));
+  console.log('🧪 MCP Session Test');
+  console.log('═'.repeat(60));
+
+  // Step 1: Initialize session
+  console.log('\n📋 Step 1: Initialize session');
+  const sessionId = await initSession();
+  console.log(`Session ID: ${sessionId || 'none'}`);
+
+  // Step 2: Call tools/list to see available tools
+  console.log('\n📋 Step 2: List available tools');
+  const listRes = await fetch(MCP_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(sessionId ? { 'mcp-session-id': sessionId } : {}),
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 2,
+      method: 'tools/list',
+      params: {},
+    }),
+  });
+  const listText = await listRes.text();
+  console.log('Tools response:', listText.slice(0, 500));
+
+  // Step 3: Try add_memory with session
+  console.log('\n📋 Step 3: Test add_memory');
+  const addRes = await callTool(sessionId, 'add_memory', {
+    name: 'Test Episode',
+    episode_body: 'This is a test episode for MCP testing. John works at Acme Corp.',
+    source: 'text',
+    group_id: 'mcp-test',
+  });
+  console.log(`Duration: ${addRes.duration}ms`);
+  console.log('Response:', addRes.raw.slice(0, 300));
+  console.log('Response headers:', addRes.headers);
+
+  // Step 4: Search nodes
+  console.log('\n📋 Step 4: Test search_nodes');
+  await Bun.sleep(2000); // Wait for processing
+  const searchRes = await callTool(sessionId, 'search_nodes', {
+    query: 'Acme Corp',
+    max_nodes: 5,
+  });
+  console.log(`Duration: ${searchRes.duration}ms`);
+  console.log('Response:', searchRes.raw.slice(0, 500));
+}
+
+main();

package/.deepquark/skills/bundled/knowledge-graph/server/test-model-combinations.ts

@@ -0,0 +1,316 @@
+#!/usr/bin/env bun
+/**
+ * Test multiple LLM model combinations via MCP
+ * Restarts container with different configs for each model
+ */
+
+import { $ } from 'bun';
+
+const MCP_URL = 'http://localhost:8000/mcp';
+const ACCEPT = 'application/json, text/event-stream';
+
+// Models to test (all 100% pass rate from benchmarks)
+const LLM_MODELS = [
+  { name: 'Llama 3.1 8B', model: 'meta-llama/llama-3.1-8b-instruct', cost: 0.0145 },
+  { name: 'DeepSeek V3', model: 'deepseek/deepseek-chat', cost: 0.0585 },
+  { name: 'GPT-4o Mini', model: 'openai/gpt-4o-mini', cost: 0.129 },
+  { name: 'Gemini 2.0 Flash', model: 'google/gemini-2.0-flash-001', cost: 0.125 },
+];
+
+// Get API keys from environment
+const OPENROUTER_API_KEY = process.env.OPENROUTER_API_KEY;
+if (!OPENROUTER_API_KEY) {
+  console.error('❌ OPENROUTER_API_KEY not set');
+  console.log('\nUsage: OPENROUTER_API_KEY=sk-or-v1-... bun test-model-combinations.ts');
+  process.exit(1);
+}
+
+const TEST_EPISODES = [
+  {
+    name: 'Tech Stack',
+    body: 'Team uses TypeScript with Bun. Sarah chose Hono for HTTP framework.',
+    group: 'model-test',
+  },
+  {
+    name: 'Partnership',
+    body: 'John Smith from Acme Corp met CTO Alice Chen about payment API integration.',
+    group: 'model-test',
+  },
+];
+
+let sessionId: string | null = null;
+
+async function mcpRequest(method: string, params: any = {}): Promise<any> {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    Accept: ACCEPT,
+  };
+  if (sessionId) headers['mcp-session-id'] = sessionId;
+
+  const res = await fetch(MCP_URL, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method, params }),
+  });
+
+  const newSessionId = res.headers.get('mcp-session-id');
+  if (newSessionId) sessionId = newSessionId;
+
+  const text = await res.text();
+  let result: any = null;
+  let error: any = null;
+
+  for (const line of text.split('\n')) {
+    if (line.startsWith('data: ')) {
+      try {
+        const data = JSON.parse(line.slice(6));
+        if (data.result) result = data.result;
+        if (data.error) error = data.error;
+      } catch {}
+    }
+  }
+
+  if (!result && !error) {
+    try {
+      const json = JSON.parse(text);
+      result = json.result;
+      error = json.error;
+    } catch {}
+  }
+
+  return { result, error, raw: text };
+}
+
+async function callTool(
+  name: string,
+  args: any
+): Promise<{ success: boolean; data: any; duration: number }> {
+  const start = Date.now();
+  const { result, error } = await mcpRequest('tools/call', { name, arguments: args });
+  const duration = Date.now() - start;
+
+  if (error) return { success: false, data: error, duration };
+
+  let data: any = result;
+  try {
+    if (result?.content?.[0]?.text) {
+      data = JSON.parse(result.content[0].text);
+    }
+  } catch {}
+
+  return { success: true, data, duration };
+}
+
+async function waitForHealth(maxWait = 60000): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    try {
+      const res = await fetch('http://localhost:8000/health');
+      if (res.ok) return true;
+    } catch {}
+    await Bun.sleep(1000);
+  }
+  return false;
+}
+
+async function restartWithModel(modelConfig: (typeof LLM_MODELS)[0]): Promise<boolean> {
+  console.log(`\n🔄 Restarting container with ${modelConfig.name}...`);
+
+  // Update .env file for OpenRouter
+  const envContent = `# Test configuration for ${modelConfig.name}
+OPENAI_API_KEY=${OPENROUTER_API_KEY}
+OPENAI_BASE_URL=https://openrouter.ai/api/v1
+MODEL_NAME=${modelConfig.model}
+LLM_PROVIDER=openai
+
+# Embedder (keep Ollama mxbai)
+EMBEDDER_BASE_URL=http://10.0.0.150:11434/v1
+EMBEDDER_MODEL=mxbai-embed-large
+EMBEDDER_DIMENSIONS=1024
+EMBEDDER_PROVIDER=openai
+
+# Neo4j
+NEO4J_URI=bolt://neo4j:7687
+NEO4J_USER=neo4j
+NEO4J_PASSWORD=madeinozknowledge
+`;
+
+  await Bun.write('../../config/.env.test', envContent);
+
+  // Restart container with test env
+  try {
+    await $`docker-compose -f docker-compose-neo4j.yml down graphiti-mcp`.quiet();
+    await Bun.sleep(2000);
+
+    // Start with test env file
+    await $`docker-compose -f docker-compose-neo4j.yml up -d graphiti-mcp`
+      .env({
+        ...process.env,
+        COMPOSE_ENV_FILES: '../../config/.env.test',
+      })
+      .quiet();
+
+    // Wait for health
+    const healthy = await waitForHealth();
+    if (!healthy) {
+      console.log('   ❌ Container failed to start');
+      return false;
+    }
+    console.log('   ✅ Container ready');
+    return true;
+  } catch (e: any) {
+    console.log(`   ❌ Error: ${e.message}`);
+    return false;
+  }
+}
+
+async function testModel(modelConfig: (typeof LLM_MODELS)[0]): Promise<any> {
+  sessionId = null; // Reset session
+
+  // Initialize MCP session
+  await mcpRequest('initialize', {
+    protocolVersion: '2024-11-05',
+    capabilities: {},
+    clientInfo: { name: 'model-test', version: '1.0' },
+  });
+  await mcpRequest('notifications/initialized', {});
+
+  const results = {
+    model: modelConfig.name,
+    cost: modelConfig.cost,
+    add_memory: { success: 0, total: 0, avgMs: 0 },
+    search_nodes: { success: 0, total: 0, avgMs: 0, avgResults: 0 },
+    search_facts: { success: 0, total: 0, avgMs: 0, avgResults: 0 },
+  };
+
+  // Test add_memory
+  console.log('   📥 Testing add_memory...');
+  let totalAddMs = 0;
+  for (const ep of TEST_EPISODES) {
+    const res = await callTool('add_memory', {
+      name: ep.name,
+      episode_body: ep.body,
+      source: 'text',
+      group_id: ep.group,
+    });
+    results.add_memory.total++;
+    if (res.success) results.add_memory.success++;
+    totalAddMs += res.duration;
+    await Bun.sleep(3000); // Wait for processing
+  }
+  results.add_memory.avgMs = Math.round(totalAddMs / TEST_EPISODES.length);
+
+  // Test search_nodes
+  console.log('   🔍 Testing search_nodes...');
+  const nodeQueries = ['TypeScript', 'Acme Corp'];
+  let totalSearchMs = 0;
+  let totalNodes = 0;
+  for (const q of nodeQueries) {
+    const res = await callTool('search_nodes', {
+      query: q,
+      group_ids: ['model-test'],
+      max_nodes: 10,
+    });
+    results.search_nodes.total++;
+    const nodes = res.data?.nodes || [];
+    if (nodes.length > 0) results.search_nodes.success++;
+    totalSearchMs += res.duration;
+    totalNodes += nodes.length;
+  }
+  results.search_nodes.avgMs = Math.round(totalSearchMs / nodeQueries.length);
+  results.search_nodes.avgResults = Math.round(totalNodes / nodeQueries.length);
+
+  // Test search_facts
+  console.log('   🔗 Testing search_facts...');
+  const factQueries = ['partnership', 'technology'];
+  let totalFactMs = 0;
+  let totalFacts = 0;
+  for (const q of factQueries) {
+    const res = await callTool('search_memory_facts', {
+      query: q,
+      group_ids: ['model-test'],
+      max_facts: 10,
+    });
+    results.search_facts.total++;
+    const facts = res.data?.facts || [];
+    if (facts.length > 0) results.search_facts.success++;
+    totalFactMs += res.duration;
+    totalFacts += facts.length;
+  }
+  results.search_facts.avgMs = Math.round(totalFactMs / factQueries.length);
+  results.search_facts.avgResults = Math.round(totalFacts / factQueries.length);
+
+  return results;
+}
+
+async function main() {
+  console.log('═'.repeat(60));
+  console.log('🧪 Model Combination MCP Test');
+  console.log('═'.repeat(60));
+  console.log(`\nModels to test: ${LLM_MODELS.map((m) => m.name).join(', ')}`);
+
+  const allResults: any[] = [];
+
+  for (const model of LLM_MODELS) {
+    console.log(`\n${'─'.repeat(60)}`);
+    console.log(`📋 Testing: ${model.name} (${model.model})`);
+    console.log(`${'─'.repeat(60)}`);
+
+    const started = await restartWithModel(model);
+    if (!started) {
+      allResults.push({ model: model.name, error: 'Failed to start' });
+      continue;
+    }
+
+    const results = await testModel(model);
+    allResults.push(results);
+
+    console.log(
+      `   ✅ add_memory: ${results.add_memory.success}/${results.add_memory.total} (${results.add_memory.avgMs}ms)`
+    );
+    console.log(
+      `   ✅ search_nodes: ${results.search_nodes.success}/${results.search_nodes.total} (${results.search_nodes.avgMs}ms, avg ${results.search_nodes.avgResults} results)`
+    );
+    console.log(
+      `   ✅ search_facts: ${results.search_facts.success}/${results.search_facts.total} (${results.search_facts.avgMs}ms, avg ${results.search_facts.avgResults} results)`
+    );
+  }
+
+  // Summary
+  console.log(`\n${'═'.repeat(60)}`);
+  console.log('📊 RESULTS SUMMARY');
+  console.log(`${'═'.repeat(60)}`);
+  console.log('\n| Model | Cost/1K | add_memory | search_nodes | search_facts |');
+  console.log('|-------|---------|------------|--------------|--------------|');
+  for (const r of allResults) {
+    if (r.error) {
+      console.log(`| ${r.model} | - | ERROR | ERROR | ERROR |`);
+    } else {
+      console.log(
+        `| ${r.model} | $${r.cost.toFixed(4)} | ${r.add_memory.success}/${r.add_memory.total} | ${r.search_nodes.success}/${r.search_nodes.total} | ${r.search_facts.success}/${r.search_facts.total} |`
+      );
+    }
+  }
+
+  // Save results
+  await Bun.write(
+    'model-combination-results.json',
+    JSON.stringify(
+      {
+        results: allResults,
+        timestamp: new Date().toISOString(),
+      },
+      null,
+      2
+    )
+  );
+
+  console.log('\n📁 Results saved to model-combination-results.json');
+
+  // Restore original config
+  console.log('\n🔄 Restoring original configuration...');
+  await $`docker-compose -f docker-compose-neo4j.yml down graphiti-mcp`.quiet();
+  await $`docker-compose -f docker-compose-neo4j.yml up -d graphiti-mcp`.quiet();
+}
+
+main().catch(console.error);

package/.deepquark/skills/bundled/knowledge-graph/server/test-ollama-models.ts

@@ -0,0 +1,228 @@
+#!/usr/bin/env bun
+/**
+ * Test Ollama models for JSON output compatibility with Graphiti
+ * Tests entity extraction capability similar to what Graphiti requires
+ */
+
+const OLLAMA_HOST = 'http://10.0.0.150:11434';
+
+// Test prompt similar to Graphiti's entity extraction
+const TEST_PROMPT = `Extract entities from this text and return ONLY valid JSON, no other text:
+
+Text: "John Smith works at Acme Corp in New York. He met Sarah Jones yesterday to discuss the Q4 budget."
+
+Return format:
+{"entities": [{"name": "string", "type": "string"}], "relationships": [{"source": "string", "target": "string", "type": "string"}]}`;
+
+// LLM models to test (excluding embedding models)
+const MODELS = [
+  'tulu3:latest',
+  'Qwen3:latest',
+  'Qwen3:8b',
+  'qwen3-coder:latest',
+  'phi4:latest',
+  'phi3:medium',
+  'mistral:latest',
+  'mistral:instruct',
+  'Llama3.2:latest',
+  'llama3.1:latest',
+  'gemma2:9b',
+  'dolphin-mistral:7b-v2.6-dpo-laser-q8_0',
+  'Deepseek-r1:latest',
+  'Deepseek-r1:8b',
+  'deepseek-coder-v2:latest',
+  'codestral:latest',
+];
+
+interface TestResult {
+  model: string;
+  status: 'passed' | 'failed';
+  entities?: number;
+  relationships?: number;
+  duration_ms?: number;
+  error?: string;
+  raw_output?: string;
+}
+
+function extractJSON(text: string): { entities: any[]; relationships: any[] } | null {
+  // Remove markdown code blocks
+  let clean = text.replace(/```json\n?/g, '').replace(/```\n?/g, '');
+
+  // Remove thinking tags (DeepSeek-r1 uses these)
+  clean = clean.replace(/<think>[\s\S]*?<\/think>/g, '');
+
+  // Trim whitespace
+  clean = clean.trim();
+
+  // Try direct parse first
+  try {
+    const obj = JSON.parse(clean);
+    if (obj.entities && obj.relationships) {
+      return obj;
+    }
+  } catch {}
+
+  // Try to find JSON object in response
+  const jsonMatch = clean.match(/\{[\s\S]*"entities"[\s\S]*"relationships"[\s\S]*\}/);
+  if (jsonMatch) {
+    try {
+      const obj = JSON.parse(jsonMatch[0]);
+      if (obj.entities && obj.relationships) {
+        return obj;
+      }
+    } catch {}
+  }
+
+  // Try line by line to find the JSON
+  const lines = clean.split('\n');
+  let jsonStr = '';
+  let inJson = false;
+  let braceCount = 0;
+
+  for (const line of lines) {
+    if (line.includes('{') && !inJson) {
+      inJson = true;
+    }
+    if (inJson) {
+      jsonStr += `${line}\n`;
+      braceCount += (line.match(/\{/g) || []).length;
+      braceCount -= (line.match(/\}/g) || []).length;
+      if (braceCount === 0) {
+        try {
+          const obj = JSON.parse(jsonStr.trim());
+          if (obj.entities && obj.relationships) {
+            return obj;
+          }
+        } catch {}
+        jsonStr = '';
+        inJson = false;
+      }
+    }
+  }
+
+  return null;
+}
+
+async function testModel(model: string): Promise<TestResult> {
+  console.log(`\nTesting: ${model}`);
+  console.log('---');
+
+  const startTime = Date.now();
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 120000); // 2 min timeout
+
+    const response = await fetch(`${OLLAMA_HOST}/api/generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        prompt: TEST_PROMPT,
+        stream: false,
+        options: { temperature: 0.1 },
+      }),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      const error = await response.text();
+      console.log(`  ❌ HTTP Error: ${response.status}`);
+      return { model, status: 'failed', error: `HTTP ${response.status}: ${error}` };
+    }
+
+    const data = (await response.json()) as { response?: string; error?: string };
+    const duration = Date.now() - startTime;
+
+    if (data.error) {
+      console.log(`  ❌ API Error: ${data.error}`);
+      return { model, status: 'failed', error: data.error };
+    }
+
+    if (!data.response) {
+      console.log('  ❌ No response content');
+      return { model, status: 'failed', error: 'No response content' };
+    }
+
+    const json = extractJSON(data.response);
+
+    if (json) {
+      console.log(
+        `  ✅ VALID JSON - ${json.entities.length} entities, ${json.relationships.length} relationships (${duration}ms)`
+      );
+      return {
+        model,
+        status: 'passed',
+        entities: json.entities.length,
+        relationships: json.relationships.length,
+        duration_ms: duration,
+      };
+    }
+    console.log('  ❌ Invalid JSON structure');
+    console.log(`  Preview: ${data.response.slice(0, 150)}...`);
+    return {
+      model,
+      status: 'failed',
+      error: 'Invalid JSON structure',
+      raw_output: data.response.slice(0, 300),
+    };
+  } catch (err: any) {
+    if (err.name === 'AbortError') {
+      console.log('  ❌ TIMEOUT');
+      return { model, status: 'failed', error: 'Timeout (>120s)' };
+    }
+    console.log(`  ❌ Error: ${err.message}`);
+    return { model, status: 'failed', error: err.message };
+  }
+}
+
+async function main() {
+  console.log('==============================================');
+  console.log('Ollama Model JSON Compatibility Test');
+  console.log(`Testing ${MODELS.length} models for entity extraction`);
+  console.log('==============================================');
+
+  const results: TestResult[] = [];
+
+  for (const model of MODELS) {
+    const result = await testModel(model);
+    results.push(result);
+  }
+
+  const passed = results.filter((r) => r.status === 'passed');
+  const failed = results.filter((r) => r.status === 'failed');
+
+  console.log('\n==============================================');
+  console.log('RESULTS SUMMARY');
+  console.log('==============================================\n');
+
+  console.log(`✅ PASSED (${passed.length} models):`);
+  for (const r of passed) {
+    console.log(
+      `   - ${r.model} (${r.entities} entities, ${r.relationships} rels, ${r.duration_ms}ms)`
+    );
+  }
+
+  console.log(`\n❌ FAILED (${failed.length} models):`);
+  for (const r of failed) {
+    console.log(`   - ${r.model} (${r.error})`);
+  }
+
+  // Output JSON for documentation
+  console.log('\n==============================================');
+  console.log('JSON OUTPUT (for documentation)');
+  console.log('==============================================');
+  console.log(JSON.stringify({ passed, failed }, null, 2));
+
+  // Write results to file
+  const outputPath = new URL('./test-results.json', import.meta.url).pathname;
+  await Bun.write(
+    outputPath,
+    JSON.stringify({ passed, failed, timestamp: new Date().toISOString() }, null, 2)
+  );
+  console.log(`\nResults written to: ${outputPath}`);
+}
+
+main();