@ninebix/nmt-system 1.0.0

package/dist/api/server.js

@@ -0,0 +1,2011 @@
+/**
+ * REST API Server
+ * @module api/server
+ */
+import express from 'express';
+import cors from 'cors';
+import fs from 'fs';
+import multer from 'multer';
+import { fileIngestion } from '../services/file-ingestion.js';
+import { llmService } from '../services/llm.js';
+import { validateIngestBody, validateSearchBody, validateBatchIngestBody, validateUUIDParam, validateSynapseBody, validateLLMConfig, } from './middleware/validation.js';
+import { rateLimiters } from './middleware/rate-limit.js';
+import { logger, requestLogger, errorLogger } from './middleware/logger.js';
+import { ChunkEngine } from '../core/chunk-engine.js';
+import { MerkleEngine } from '../core/merkle-engine.js';
+import { HNSWIndex } from '../core/hnsw-index.js';
+import { NeuronGraphManager } from '../core/neuron-graph.js';
+import { ChunkStore, NeuronStore, IndexStore } from '../storage/redis-adapters.js';
+import { IngestionService } from '../services/ingestion.js';
+import { QueryService } from '../services/query.js';
+import { VerificationService } from '../services/verify.js';
+import { GraphService } from '../services/graph.js';
+import { ClusteringService } from '../extensions/clustering/index.js';
+import { TopicModelingService } from '../extensions/clustering/topic-modeling.js';
+import { CommunityDetectionService } from '../extensions/clustering/community-detection.js';
+import { SemanticChunker, createSemanticSynapses } from '../core/semantic-chunker.js';
+import { HierarchicalChunker } from '../core/hierarchical-chunker.js';
+import { multiLangTokenizer, detectLanguage } from '../core/language-analyzers.js';
+import { RedisOntologyStore } from '../storage/redis-ontology-store.js';
+import { DynamicLearningService } from '../services/learning.js';
+import { AutoLearningService } from '../services/auto-learning.js';
+import { WebSearchService } from '../services/web-search.js';
+import { localEmbedding } from '../core/local-embedding.js';
+import { advancedEmbedding } from '../core/advanced-embedding.js';
+import { MultiLayerReasoningEngine } from '../core/multi-layer-reasoning.js';
+import { embeddingSimilarity, calculateSimilarity, findSynonyms as findEmbeddingSynonyms } from '../core/embedding-similarity.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * NMT API Server
+ */
+export class NMTServer {
+    app;
+    port;
+    dataDir;
+    // Core components
+    chunkEngine;
+    merkleEngine;
+    hnswIndex;
+    // Storage (Redis-based adapters)
+    chunkStore;
+    neuronStore;
+    indexStore;
+    // Services
+    graphManager;
+    ingestionService;
+    queryService;
+    verifyService;
+    graphService;
+    clusteringService;
+    topicModeling;
+    communityDetection;
+    semanticChunker;
+    hierarchicalChunker;
+    // Learning & Ontology (Redis-based)
+    ontologyStore;
+    learningService;
+    autoLearningService;
+    webSearchService;
+    localEmbeddingService;
+    advancedEmbeddingService;
+    reasoningEngine;
+    initialized = false;
+    constructor(options = {}) {
+        this.port = options.port ?? 3000;
+        this.dataDir = options.dataDir ?? './data';
+        this.app = express();
+        // Middleware
+        this.app.use(express.json({ limit: '10mb' }));
+        this.app.use(express.urlencoded({ extended: true }));
+        // CORS configuration - secure for production
+        const corsOrigins = options.corsOrigins ?? (process.env.NODE_ENV === 'production'
+            ? (process.env.CORS_ORIGINS?.split(',') || ['http://localhost:3000'])
+            : '*');
+        this.app.use(cors({
+            origin: corsOrigins,
+            methods: ['GET', 'POST', 'PUT', 'DELETE'],
+            allowedHeaders: ['Content-Type', 'Authorization'],
+            credentials: true,
+        }));
+        // Request logging
+        this.app.use(requestLogger);
+        // Global rate limiter
+        this.app.use('/api/', rateLimiters.general);
+        this.setupRoutes();
+        this.setupErrorHandling();
+    }
+    /**
+     * Initialize all components
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        // Initialize core engines
+        this.chunkEngine = new ChunkEngine();
+        this.merkleEngine = new MerkleEngine();
+        this.hnswIndex = new HNSWIndex();
+        // Initialize storage
+        this.chunkStore = new ChunkStore({ dataDir: this.dataDir });
+        this.neuronStore = new NeuronStore({ dataDir: this.dataDir });
+        this.indexStore = new IndexStore({ dataDir: this.dataDir });
+        await this.chunkStore.init();
+        await this.neuronStore.init();
+        await this.indexStore.init();
+        // Try to load existing index
+        const existingIndex = await this.indexStore.load('main');
+        if (existingIndex) {
+            this.hnswIndex = existingIndex;
+        }
+        // Initialize graph manager
+        this.graphManager = new NeuronGraphManager({
+            neuronStore: this.neuronStore,
+            hnswIndex: this.hnswIndex
+        });
+        // Initialize services
+        this.ingestionService = new IngestionService(this.chunkEngine, this.merkleEngine, this.graphManager, this.chunkStore);
+        this.queryService = new QueryService(this.graphManager, this.merkleEngine, this.chunkStore, this.neuronStore);
+        this.verifyService = new VerificationService(this.merkleEngine, this.chunkStore, this.neuronStore);
+        this.graphService = new GraphService(this.graphManager, this.neuronStore);
+        // Initialize clustering extensions
+        this.clusteringService = new ClusteringService(this.neuronStore);
+        this.topicModeling = new TopicModelingService(this.neuronStore);
+        this.communityDetection = new CommunityDetectionService(this.neuronStore);
+        // Initialize chunkers
+        this.semanticChunker = new SemanticChunker();
+        this.hierarchicalChunker = new HierarchicalChunker();
+        // Initialize Redis-based ontology store
+        this.ontologyStore = new RedisOntologyStore({
+            host: process.env.REDIS_HOST || 'localhost',
+            port: parseInt(process.env.REDIS_PORT || '6379'),
+            password: process.env.REDIS_PASSWORD,
+            db: parseInt(process.env.REDIS_DB || '0'),
+            keyPrefix: 'nmt:'
+        });
+        await this.ontologyStore.init();
+        // Import default data if empty
+        const imported = await this.ontologyStore.importDefaultData();
+        if (imported > 0) {
+            console.log(`Imported ${imported} default semantic groups`);
+        }
+        this.learningService = new DynamicLearningService(this.ontologyStore);
+        // Initialize Local Embedding Service
+        this.localEmbeddingService = localEmbedding;
+        try {
+            await this.localEmbeddingService.init();
+            console.log('Local embedding model loaded');
+        }
+        catch (error) {
+            console.warn('Local embedding model failed to load, will use fallback:', error);
+        }
+        // Initialize Auto Learning Service
+        this.autoLearningService = new AutoLearningService(this.ontologyStore, this.localEmbeddingService);
+        await this.autoLearningService.init();
+        console.log('Auto Learning Service initialized');
+        // Initialize Web Search Service
+        this.webSearchService = new WebSearchService(this.ontologyStore, this.localEmbeddingService);
+        console.log('Web Search Service initialized');
+        // Initialize Advanced Embedding Service (bge-m3 1024d)
+        this.advancedEmbeddingService = advancedEmbedding;
+        // Note: bge-m3 loads in background, uses fallback initially
+        this.advancedEmbeddingService.init(true).then(() => {
+            console.log('Advanced embedding model (bge-m3) loaded');
+        }).catch(err => {
+            console.warn('Advanced embedding load deferred:', err.message);
+        });
+        // Initialize Multi-Layer Reasoning Engine
+        this.reasoningEngine = new MultiLayerReasoningEngine(this.ontologyStore, this.advancedEmbeddingService);
+        console.log('Multi-Layer Reasoning Engine initialized');
+        this.initialized = true;
+    }
+    /**
+     * Start the server
+     */
+    async start() {
+        await this.init();
+        return new Promise((resolve) => {
+            this.app.listen(this.port, () => {
+                console.log(`NMT Server running on http://localhost:${this.port}`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the server and cleanup
+     */
+    async stop() {
+        // Save index
+        await this.indexStore.save('main', this.hnswIndex);
+        // Close storage
+        await this.chunkStore.close();
+        await this.neuronStore.close();
+        await this.indexStore.close();
+        await this.ontologyStore.close();
+        this.initialized = false;
+    }
+    /**
+     * Setup API routes
+     */
+    setupRoutes() {
+        const api = express.Router();
+        // Health check
+        api.get('/health', (req, res) => {
+            res.json({
+                status: 'healthy',
+                initialized: this.initialized,
+                timestamp: new Date().toISOString()
+            });
+        });
+        // ==================== Ingestion Routes ====================
+        // Ingest text
+        api.post('/ingest', rateLimiters.ingest, validateIngestBody, async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { text, sourceType, tags, useCDC, autoConnect } = req.body;
+                if (!text) {
+                    res.status(400).json({ error: 'Text is required' });
+                    return;
+                }
+                const neuron = await this.ingestionService.ingestText(text, {
+                    sourceType,
+                    tags,
+                    useCDC,
+                    autoConnect
+                });
+                res.status(201).json({
+                    id: neuron.id,
+                    merkleRoot: neuron.merkleRoot,
+                    chunkCount: neuron.chunkHashes.length
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Batch ingest
+        api.post('/ingest/batch', rateLimiters.ingest, validateBatchIngestBody, async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { texts, sourceType, tags } = req.body;
+                if (!texts || !Array.isArray(texts)) {
+                    res.status(400).json({ error: 'Texts array is required' });
+                    return;
+                }
+                const neurons = await this.ingestionService.ingestBatch(texts, {
+                    sourceType,
+                    tags
+                });
+                res.status(201).json({
+                    count: neurons.length,
+                    neurons: neurons.map(n => ({
+                        id: n.id,
+                        merkleRoot: n.merkleRoot
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get job status
+        api.get('/ingest/jobs/:jobId', (req, res) => {
+            this.ensureInitialized();
+            const job = this.ingestionService.getJobStatus(req.params.jobId);
+            if (!job) {
+                res.status(404).json({ error: 'Job not found' });
+                return;
+            }
+            res.json(job);
+        });
+        // ==================== Query Routes ====================
+        // Search by text
+        api.post('/search', rateLimiters.search, validateSearchBody, async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, k, threshold, includeContent, includeProof, tags, sourceType } = req.body;
+                if (!query) {
+                    res.status(400).json({ error: 'Query is required' });
+                    return;
+                }
+                const results = await this.queryService.search(query, {
+                    k,
+                    threshold,
+                    includeContent,
+                    includeProof,
+                    tags,
+                    sourceType
+                });
+                // Auto-learn from query (non-blocking)
+                this.autoLearningService.learnFromQuery(query, results.map(r => ({
+                    id: r.neuron.id,
+                    content: r.content,
+                    score: r.score
+                }))).catch(err => console.error('Auto-learn error:', err));
+                res.json({
+                    count: results.length,
+                    results: results.map(r => ({
+                        id: r.neuron.id,
+                        score: r.score,
+                        merkleRoot: r.neuron.merkleRoot,
+                        tags: r.neuron.metadata.tags,
+                        content: r.content,
+                        proof: r.proof
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Search similar to neuron
+        api.get('/search/similar/:neuronId', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { neuronId } = req.params;
+                const k = parseInt(req.query.k) || 10;
+                const results = await this.queryService.searchSimilarTo(neuronId, { k });
+                res.json({
+                    count: results.length,
+                    results: results.map(r => ({
+                        id: r.neuron.id,
+                        score: r.score,
+                        merkleRoot: r.neuron.merkleRoot
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Neuron Routes ====================
+        // Get neuron by ID
+        api.get('/neurons/:id', validateUUIDParam('id'), async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+                const neuron = await this.queryService.getNeuron(id);
+                if (!neuron) {
+                    res.status(404).json({ error: 'Neuron not found' });
+                    return;
+                }
+                res.json({
+                    id: neuron.id,
+                    merkleRoot: neuron.merkleRoot,
+                    chunkCount: neuron.chunkHashes.length,
+                    metadata: neuron.metadata,
+                    synapses: {
+                        outgoing: neuron.outgoingSynapses.length,
+                        incoming: neuron.incomingSynapses.length
+                    }
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get neuron content
+        api.get('/neurons/:id/content', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const neuron = await this.queryService.getNeuron(req.params.id);
+                if (!neuron) {
+                    res.status(404).json({ error: 'Neuron not found' });
+                    return;
+                }
+                const content = await this.queryService.getContent(neuron);
+                res.json({ id: neuron.id, content });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Delete neuron
+        api.delete('/neurons/:id', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const deleted = await this.graphManager.deleteNeuron(req.params.id);
+                if (!deleted) {
+                    res.status(404).json({ error: 'Neuron not found' });
+                    return;
+                }
+                res.json({ deleted: true });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get neurons by tags
+        api.get('/neurons', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const tags = req.query.tags?.split(',');
+                const sourceType = req.query.sourceType;
+                let neurons;
+                if (tags) {
+                    neurons = await this.queryService.getNeuronsByTags(tags);
+                }
+                else if (sourceType) {
+                    neurons = await this.queryService.getNeuronsBySourceType(sourceType);
+                }
+                else {
+                    neurons = await this.queryService.getRecentlyAccessed(100);
+                }
+                res.json({
+                    count: neurons.length,
+                    neurons: neurons.map(n => ({
+                        id: n.id,
+                        merkleRoot: n.merkleRoot,
+                        tags: n.metadata.tags,
+                        sourceType: n.metadata.sourceType
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Synapse Routes ====================
+        // Create synapse
+        api.post('/synapses', validateSynapseBody, async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { sourceId, targetId, type, weight, bidirectional } = req.body;
+                if (!sourceId || !targetId || !type) {
+                    res.status(400).json({ error: 'sourceId, targetId, and type are required' });
+                    return;
+                }
+                const synapse = await this.graphManager.connect(sourceId, targetId, type, weight, bidirectional);
+                if (!synapse) {
+                    res.status(400).json({ error: 'Failed to create synapse' });
+                    return;
+                }
+                res.status(201).json({
+                    id: synapse.id,
+                    sourceId: synapse.sourceId,
+                    targetId: synapse.targetId,
+                    type: synapse.type,
+                    weight: synapse.weight
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Delete synapse
+        api.delete('/synapses/:id', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const deleted = await this.graphManager.disconnect(req.params.id);
+                if (!deleted) {
+                    res.status(404).json({ error: 'Synapse not found' });
+                    return;
+                }
+                res.json({ deleted: true });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Verification Routes ====================
+        // Verify neuron
+        api.get('/verify/:neuronId', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const result = await this.verifyService.verifyNeuron(req.params.neuronId);
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Generate proof
+        api.get('/verify/:neuronId/proof/:chunkIndex', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const chunkIndex = parseInt(req.params.chunkIndex);
+                const result = await this.verifyService.generateAndVerifyProof(req.params.neuronId, chunkIndex, { verifyChunkData: true });
+                if (!result.proof) {
+                    res.status(404).json({ error: 'Could not generate proof' });
+                    return;
+                }
+                res.json({
+                    proof: result.proof,
+                    valid: result.valid,
+                    chunkValid: result.chunkValid
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Verify all
+        api.get('/verify', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const result = await this.verifyService.verifyAll();
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Graph Routes ====================
+        // Traverse graph
+        api.post('/graph/traverse', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { startId, strategy, maxDepth } = req.body;
+                if (!startId) {
+                    res.status(400).json({ error: 'startId is required' });
+                    return;
+                }
+                const result = await this.graphService.traverse(startId, strategy, maxDepth);
+                res.json({
+                    pathCount: result.paths.length,
+                    visitedCount: result.visited.size,
+                    totalWeight: result.totalWeight,
+                    paths: result.paths.map(p => ({
+                        neurons: p.neurons.map(n => n.id),
+                        synapseCount: p.synapses.length,
+                        weight: p.totalWeight
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find path
+        api.post('/graph/path', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { sourceId, targetId, maxDepth } = req.body;
+                if (!sourceId || !targetId) {
+                    res.status(400).json({ error: 'sourceId and targetId are required' });
+                    return;
+                }
+                const path = await this.graphService.findPath(sourceId, targetId, { maxDepth });
+                if (!path) {
+                    res.json({ found: false });
+                    return;
+                }
+                res.json({
+                    found: true,
+                    path: {
+                        neurons: path.neurons.map(n => n.id),
+                        synapses: path.synapses.map(s => s.id),
+                        weight: path.totalWeight
+                    }
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get subgraph
+        api.get('/graph/subgraph/:centerId', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const radius = parseInt(req.query.radius) || 2;
+                const result = await this.graphService.getSubgraph(req.params.centerId, radius);
+                res.json({
+                    neuronCount: result.neurons.length,
+                    synapseCount: result.synapses.length,
+                    neurons: result.neurons.map(n => ({
+                        id: n.id,
+                        merkleRoot: n.merkleRoot
+                    })),
+                    synapses: result.synapses.map(s => ({
+                        id: s.id,
+                        source: s.sourceId,
+                        target: s.targetId,
+                        type: s.type,
+                        weight: s.weight
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Analyze graph
+        api.get('/graph/analyze', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const analysis = await this.graphService.analyze();
+                res.json(analysis);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get full graph data for visualization
+        api.get('/graph/full', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const limit = parseInt(req.query.limit) || 100;
+                // Get all neurons
+                const neuronIds = await this.neuronStore.getAllNeuronIds();
+                const neurons = [];
+                for (const id of neuronIds.slice(0, limit)) {
+                    const neuron = await this.neuronStore.getNeuron(id);
+                    if (neuron) {
+                        neurons.push({
+                            id: neuron.id,
+                            merkleRoot: neuron.merkleRoot,
+                            tags: neuron.metadata.tags || [],
+                            accessCount: neuron.metadata.accessCount || 0,
+                        });
+                    }
+                }
+                // Get all synapses for these neurons
+                const synapses = [];
+                const neuronIdSet = new Set(neurons.map(n => n.id));
+                for (const neuron of neurons) {
+                    const outgoing = await this.neuronStore.getOutgoingSynapses(neuron.id);
+                    for (const synapse of outgoing) {
+                        if (neuronIdSet.has(synapse.targetId)) {
+                            synapses.push({
+                                id: synapse.id,
+                                source: synapse.sourceId,
+                                target: synapse.targetId,
+                                type: synapse.type,
+                                weight: synapse.weight,
+                            });
+                        }
+                    }
+                }
+                res.json({
+                    nodes: neurons,
+                    links: synapses,
+                    totalNeurons: neuronIds.length,
+                    totalDisplayed: neurons.length,
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Clustering Routes ====================
+        // K-means clustering
+        api.post('/clusters/kmeans', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { k, maxIterations, tolerance, initMethod } = req.body;
+                if (!k || k < 2) {
+                    res.status(400).json({ error: 'k must be at least 2' });
+                    return;
+                }
+                const result = await this.clusteringService.kmeans({
+                    k,
+                    maxIterations,
+                    tolerance,
+                    initMethod
+                });
+                res.json({
+                    clusterCount: result.clusters.length,
+                    iterations: result.iterations,
+                    silhouetteScore: result.silhouetteScore,
+                    clusters: result.clusters.map(c => ({
+                        id: c.id,
+                        memberCount: c.members.length,
+                        avgSimilarity: c.avgSimilarity
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // DBSCAN clustering
+        api.post('/clusters/dbscan', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { eps = 0.3, minPts = 3 } = req.body;
+                const result = await this.clusteringService.dbscan({ eps, minPts });
+                res.json({
+                    clusterCount: result.clusters.length,
+                    noiseCount: result.noise?.length || 0,
+                    clusters: result.clusters.map(c => ({
+                        id: c.id,
+                        memberCount: c.members.length,
+                        avgSimilarity: c.avgSimilarity
+                    })),
+                    noise: result.noise
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Hierarchical clustering
+        api.post('/clusters/hierarchical', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { targetClusters = 5, linkage = 'average' } = req.body;
+                const result = await this.clusteringService.hierarchical(targetClusters, linkage);
+                res.json({
+                    clusterCount: result.clusters.length,
+                    clusters: result.clusters.map(c => ({
+                        id: c.id,
+                        memberCount: c.members.length,
+                        avgSimilarity: c.avgSimilarity
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get all clusters
+        api.get('/clusters', (req, res) => {
+            this.ensureInitialized();
+            const clusters = this.clusteringService.getAllClusters();
+            res.json({
+                count: clusters.length,
+                clusters: clusters.map(c => ({
+                    id: c.id,
+                    name: c.name,
+                    memberCount: c.members.length,
+                    avgSimilarity: c.avgSimilarity,
+                    algorithm: c.metadata.algorithmUsed
+                }))
+            });
+        });
+        // Get cluster by ID
+        api.get('/clusters/:id', (req, res) => {
+            this.ensureInitialized();
+            const cluster = this.clusteringService.getCluster(req.params.id);
+            if (!cluster) {
+                res.status(404).json({ error: 'Cluster not found' });
+                return;
+            }
+            res.json(cluster);
+        });
+        // Get cluster stats
+        api.get('/clusters/stats/summary', (req, res) => {
+            this.ensureInitialized();
+            const stats = this.clusteringService.getStats();
+            res.json(stats);
+        });
+        // Topic modeling
+        api.post('/topics/extract', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { numTopics = 10, topTermsPerTopic = 10 } = req.body;
+                const result = await this.topicModeling.extractTopics({
+                    numTopics,
+                    topTermsPerTopic
+                });
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Community detection - Louvain
+        api.post('/communities/louvain', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { resolution = 1.0, minCommunitySize = 2 } = req.body;
+                const result = await this.communityDetection.louvain({
+                    resolution,
+                    minCommunitySize
+                });
+                res.json({
+                    communityCount: result.communities.length,
+                    modularity: result.modularity,
+                    coverage: result.coverage,
+                    communities: result.communities.map(c => ({
+                        id: c.id,
+                        memberCount: c.members.length,
+                        modularity: c.modularity,
+                        density: c.density
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Community detection - Label Propagation
+        api.post('/communities/label-propagation', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { maxIterations = 100, minCommunitySize = 2 } = req.body;
+                const result = await this.communityDetection.labelPropagation({
+                    maxIterations,
+                    minCommunitySize
+                });
+                res.json({
+                    communityCount: result.communities.length,
+                    modularity: result.modularity,
+                    coverage: result.coverage,
+                    communities: result.communities.map(c => ({
+                        id: c.id,
+                        memberCount: c.members.length,
+                        density: c.density
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Stats Routes ====================
+        api.get('/stats', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const graphStats = await this.graphManager.getStats();
+                const chunkStats = await this.chunkStore.getStats();
+                res.json({
+                    neurons: graphStats.neuronCount,
+                    synapses: graphStats.synapseCount,
+                    chunks: chunkStats.totalChunks,
+                    totalChunkSize: chunkStats.totalSize,
+                    indexNodes: graphStats.indexStats.totalNodes,
+                    indexMaxLayer: graphStats.indexStats.maxLayer
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Config Routes ====================
+        // Get current configuration
+        api.get('/config', (_req, res) => {
+            res.json({
+                hnsw: {
+                    M: 16,
+                    efConstruction: 200,
+                    efSearch: 50
+                },
+                storage: {
+                    dataDir: this.dataDir,
+                    chunkSize: 4096,
+                    chunkingMode: 'fixed'
+                },
+                connection: {
+                    semanticThreshold: 0.7,
+                    maxConnections: 20,
+                    autoConnect: true
+                },
+                verification: {
+                    verifyOnRead: true,
+                    autoProof: true,
+                    periodicCheck: false
+                }
+            });
+        });
+        // Update configuration (placeholder - some settings require restart)
+        api.put('/config', async (req, res, next) => {
+            try {
+                // For now, just acknowledge the update
+                // In a real implementation, we'd persist these settings and apply them
+                const config = req.body;
+                console.log('Config update requested:', config);
+                res.json({
+                    success: true,
+                    message: 'Configuration updated (note: some settings require restart)'
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== File Upload Routes ====================
+        // Configure multer for file uploads
+        const upload = multer({
+            storage: multer.memoryStorage(),
+            limits: { fileSize: 50 * 1024 * 1024 }, // 50MB limit
+            fileFilter: (_req, file, cb) => {
+                const allowedTypes = [
+                    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', // xlsx
+                    'application/vnd.ms-excel', // xls
+                    'text/csv',
+                    'application/csv',
+                ];
+                const allowedExts = ['.xlsx', '.xls', '.csv'];
+                const ext = file.originalname.toLowerCase().slice(file.originalname.lastIndexOf('.'));
+                if (allowedTypes.includes(file.mimetype) || allowedExts.includes(ext)) {
+                    cb(null, true);
+                }
+                else {
+                    cb(new Error(`Unsupported file type: ${file.mimetype}`));
+                }
+            },
+        });
+        // Upload and preview file
+        api.post('/files/preview', upload.single('file'), async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                if (!req.file) {
+                    res.status(400).json({ error: 'No file uploaded' });
+                    return;
+                }
+                const maxRows = parseInt(req.body.maxRows) || 10;
+                const preview = fileIngestion.previewFile(req.file.buffer, req.file.originalname, maxRows);
+                res.json({
+                    fileName: req.file.originalname,
+                    fileSize: req.file.size,
+                    fileType: preview.fileType,
+                    sheetName: preview.sheetName,
+                    headers: preview.headers,
+                    totalRows: preview.totalRows,
+                    previewRows: preview.rows.map(r => ({
+                        rowIndex: r.rowIndex,
+                        data: r.data,
+                        textPreview: r.text.slice(0, 200),
+                    })),
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get sheet names from Excel file
+        api.post('/files/sheets', upload.single('file'), async (req, res, next) => {
+            try {
+                if (!req.file) {
+                    res.status(400).json({ error: 'No file uploaded' });
+                    return;
+                }
+                const sheets = fileIngestion.getSheetNames(req.file.buffer);
+                res.json({ sheets });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Upload and ingest file
+        api.post('/files/ingest', rateLimiters.upload, upload.single('file'), async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                if (!req.file) {
+                    res.status(400).json({ error: 'No file uploaded' });
+                    return;
+                }
+                const options = {
+                    headerRow: req.body.headerRow ? parseInt(req.body.headerRow) : undefined,
+                    startRow: req.body.startRow ? parseInt(req.body.startRow) : undefined,
+                    sheetName: req.body.sheetName,
+                    sheetIndex: req.body.sheetIndex ? parseInt(req.body.sheetIndex) : undefined,
+                    columns: req.body.columns ? JSON.parse(req.body.columns) : undefined,
+                    excludeColumns: req.body.excludeColumns ? JSON.parse(req.body.excludeColumns) : undefined,
+                    textTemplate: req.body.textTemplate,
+                    sourceType: req.body.sourceType || 'file-upload',
+                    tags: req.body.tags ? JSON.parse(req.body.tags) : [req.file.originalname],
+                    maxRows: req.body.maxRows ? parseInt(req.body.maxRows) : undefined,
+                };
+                const parsed = fileIngestion.parseFile(req.file.buffer, req.file.originalname, options);
+                // Create neurons for each row
+                const neurons = [];
+                const errors = [];
+                for (const row of parsed.rows) {
+                    try {
+                        const neuron = await this.ingestionService.ingestText(row.text, {
+                            sourceType: options.sourceType,
+                            tags: [...(options.tags || []), `row-${row.rowIndex}`],
+                        });
+                        neurons.push({
+                            id: neuron.id,
+                            rowIndex: row.rowIndex,
+                            preview: row.text.slice(0, 100),
+                        });
+                    }
+                    catch (err) {
+                        errors.push(`Row ${row.rowIndex}: ${err.message}`);
+                    }
+                }
+                res.json({
+                    fileName: req.file.originalname,
+                    fileType: parsed.fileType,
+                    totalRows: parsed.totalRows,
+                    neuronsCreated: neurons.length,
+                    neurons,
+                    errors,
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== LLM Routes ====================
+        // Configure LLM
+        api.post('/llm/configure', rateLimiters.config, validateLLMConfig, (req, res, next) => {
+            try {
+                const { provider, apiKey, model, maxTokens, temperature } = req.body;
+                if (!provider || !apiKey) {
+                    res.status(400).json({ error: 'provider and apiKey are required' });
+                    return;
+                }
+                const validProviders = ['openai', 'huggingface', 'grok'];
+                if (!validProviders.includes(provider)) {
+                    res.status(400).json({
+                        error: `Invalid provider. Must be one of: ${validProviders.join(', ')}`
+                    });
+                    return;
+                }
+                llmService.configure({
+                    provider,
+                    apiKey,
+                    model,
+                    maxTokens,
+                    temperature,
+                });
+                res.json({
+                    success: true,
+                    message: `LLM configured with ${provider}`,
+                    config: llmService.getConfig(),
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get LLM config (without API key)
+        api.get('/llm/config', (_req, res) => {
+            const config = llmService.getConfig();
+            res.json({
+                configured: llmService.isConfigured(),
+                config,
+            });
+        });
+        // Get available models for a provider
+        api.get('/llm/models/:provider', (req, res) => {
+            const provider = req.params.provider;
+            const models = llmService.getAvailableModels(provider);
+            res.json({ provider, models });
+        });
+        // Simple chat completion
+        api.post('/llm/chat', rateLimiters.llm, async (req, res, next) => {
+            try {
+                const { messages, provider, apiKey, model, maxTokens, temperature } = req.body;
+                if (!messages || !Array.isArray(messages)) {
+                    res.status(400).json({ error: 'messages array is required' });
+                    return;
+                }
+                // Allow per-request config override
+                const config = apiKey ? { provider, apiKey, model, maxTokens, temperature } : undefined;
+                const response = await llmService.chat(messages, config);
+                res.json(response);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // RAG query - search + LLM
+        api.post('/rag/query', rateLimiters.llm, async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, k = 5, threshold = 0.3, systemPrompt, maxContextLength, provider, apiKey, model } = req.body;
+                if (!query) {
+                    res.status(400).json({ error: 'query is required' });
+                    return;
+                }
+                // Check if LLM is configured
+                const config = apiKey ? { provider, apiKey, model } : undefined;
+                if (!config && !llmService.isConfigured()) {
+                    res.status(400).json({
+                        error: 'LLM not configured. Please provide API key or configure LLM first.'
+                    });
+                    return;
+                }
+                // Step 1: Retrieve relevant contexts
+                const searchResults = await this.queryService.search(query, {
+                    k,
+                    threshold,
+                    includeContent: true,
+                });
+                const contexts = searchResults.map(r => ({
+                    id: r.neuron.id,
+                    content: r.content || '',
+                    score: r.score,
+                    metadata: {
+                        tags: r.neuron.metadata.tags,
+                        sourceType: r.neuron.metadata.sourceType,
+                    },
+                }));
+                // Step 2: Generate response with LLM
+                const llmResponse = await llmService.ragQuery({
+                    query,
+                    contexts,
+                    systemPrompt,
+                    maxContextLength,
+                }, config);
+                res.json({
+                    query,
+                    answer: llmResponse.content,
+                    contexts: contexts.map(c => ({
+                        id: c.id,
+                        score: c.score,
+                        preview: c.content.slice(0, 200),
+                        metadata: c.metadata,
+                    })),
+                    llm: {
+                        model: llmResponse.model,
+                        provider: llmResponse.provider,
+                        usage: llmResponse.usage,
+                        processingTime: llmResponse.processingTime,
+                    },
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Semantic Chunking Routes ====================
+        // Semantic chunk - build semantic tree
+        api.post('/semantic/chunk', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { text, addConcepts } = req.body;
+                if (!text) {
+                    res.status(400).json({ error: 'Text is required' });
+                    return;
+                }
+                // Add custom concepts if provided
+                if (addConcepts && Array.isArray(addConcepts)) {
+                    for (const c of addConcepts) {
+                        if (c.concept && c.parents) {
+                            this.semanticChunker.addConcept(c.concept, c.parents, c.type || 'is-a');
+                        }
+                    }
+                }
+                const tree = this.semanticChunker.chunk(text);
+                const synapses = createSemanticSynapses(tree);
+                // Build visualization
+                const visualization = this.semanticChunker.visualize(tree);
+                res.json({
+                    concepts: tree.nodes.size,
+                    roots: tree.roots.map(r => r.concept),
+                    maxDepth: Math.max(...[...tree.byDepth.keys()]),
+                    synapses: synapses.length,
+                    tree: [...tree.nodes.values()].map(n => ({
+                        id: n.id,
+                        concept: n.concept,
+                        depth: n.depth,
+                        parentId: n.parentId,
+                        childIds: n.childIds,
+                        relations: n.relations.map(r => ({
+                            target: r.targetConcept,
+                            type: r.type,
+                            weight: r.weight
+                        }))
+                    })),
+                    visualization
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get semantic chain for a concept
+        api.get('/semantic/chain/:concept', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const chain = this.semanticChunker.buildSemanticChain(req.params.concept);
+                res.json({
+                    concept: req.params.concept,
+                    chain,
+                    depth: chain.length - 1
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find relation between two concepts
+        api.get('/semantic/relation', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { concept1, concept2 } = req.query;
+                if (!concept1 || !concept2) {
+                    res.status(400).json({ error: 'concept1 and concept2 are required' });
+                    return;
+                }
+                const relation = this.semanticChunker.findRelation(concept1, concept2);
+                res.json({
+                    concept1,
+                    concept2,
+                    relation: relation ? {
+                        type: relation.type,
+                        weight: relation.weight,
+                        bidirectional: relation.bidirectional
+                    } : null
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find descendants of a concept
+        api.get('/semantic/descendants/:concept', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const descendants = this.semanticChunker.findDescendants(req.params.concept);
+                res.json({
+                    concept: req.params.concept,
+                    descendants,
+                    count: descendants.length
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find ancestors of a concept
+        api.get('/semantic/ancestors/:concept', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const ancestors = this.semanticChunker.findAncestors(req.params.concept);
+                res.json({
+                    concept: req.params.concept,
+                    ancestors,
+                    count: ancestors.length
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find siblings of a concept
+        api.get('/semantic/siblings/:concept', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const siblings = this.semanticChunker.findSiblings(req.params.concept);
+                res.json({
+                    concept: req.params.concept,
+                    siblings,
+                    count: siblings.length
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get ontology stats
+        api.get('/semantic/stats', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const stats = this.semanticChunker.getStats();
+                res.json(stats);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Learning & Ontology Routes ====================
+        // Learn from text (auto-extract relations)
+        api.post('/learning/text', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { text, source } = req.body;
+                if (!text) {
+                    res.status(400).json({ error: 'Text is required' });
+                    return;
+                }
+                const results = await this.learningService.learnFromText(text, source || 'api');
+                res.json({
+                    text: text.slice(0, 100) + (text.length > 100 ? '...' : ''),
+                    learned: results.filter(r => r.learned).length,
+                    results: results.map(r => ({
+                        learned: r.learned,
+                        type: r.type,
+                        concept1: r.concept1,
+                        concept2: r.concept2,
+                        confidence: r.confidence,
+                        message: r.message
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Learn synonym explicitly
+        api.post('/learning/synonym', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { word, synonym, source } = req.body;
+                if (!word || !synonym) {
+                    res.status(400).json({ error: 'word and synonym are required' });
+                    return;
+                }
+                const result = await this.learningService.learnSynonym(word, synonym, source || 'api');
+                res.json({
+                    learned: result.learned,
+                    word,
+                    synonym,
+                    message: result.message
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Learn relation explicitly
+        api.post('/learning/relation', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { concept1, concept2, type, source } = req.body;
+                if (!concept1 || !concept2 || !type) {
+                    res.status(400).json({ error: 'concept1, concept2, and type are required' });
+                    return;
+                }
+                const validTypes = ['is-a', 'part-of', 'has-a', 'related-to'];
+                if (!validTypes.includes(type)) {
+                    res.status(400).json({
+                        error: `Invalid type. Must be one of: ${validTypes.join(', ')}`
+                    });
+                    return;
+                }
+                const result = await this.learningService.learnRelation(concept1, concept2, type, source || 'api');
+                res.json({
+                    learned: result.learned,
+                    concept1,
+                    concept2,
+                    type,
+                    message: result.message
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Batch learn from conversation
+        api.post('/learning/conversation', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { messages, source } = req.body;
+                if (!messages || !Array.isArray(messages)) {
+                    res.status(400).json({ error: 'messages array is required' });
+                    return;
+                }
+                const result = await this.learningService.learnFromConversation(messages, source || 'conversation');
+                res.json({
+                    totalMessages: result.totalMessages,
+                    learnedCount: result.learnedCount,
+                    results: result.results.filter(r => r.learned).map(r => ({
+                        type: r.type,
+                        concept1: r.concept1,
+                        concept2: r.concept2,
+                        message: r.message
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Auto Learning Routes ====================
+        // Get auto-learning stats
+        api.get('/auto-learning/stats', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const stats = this.autoLearningService.getStats();
+                const embeddingStats = this.localEmbeddingService.getStats();
+                res.json({
+                    autoLearning: stats,
+                    embedding: embeddingStats
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Manual feedback for auto-learning
+        api.post('/auto-learning/feedback', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, resultId, resultContent, isPositive } = req.body;
+                if (!query || !resultId) {
+                    res.status(400).json({ error: 'query and resultId are required' });
+                    return;
+                }
+                await this.autoLearningService.learnFromFeedback(query, { id: resultId, content: resultContent }, isPositive !== false);
+                res.json({
+                    success: true,
+                    message: isPositive !== false ? 'Positive feedback recorded' : 'Negative feedback recorded'
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Manual click tracking
+        api.post('/auto-learning/click', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, resultId, resultContent } = req.body;
+                if (!query || !resultId) {
+                    res.status(400).json({ error: 'query and resultId are required' });
+                    return;
+                }
+                await this.autoLearningService.learnFromClick(query, {
+                    id: resultId,
+                    content: resultContent
+                });
+                res.json({
+                    success: true,
+                    message: 'Click recorded for learning'
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get query history
+        api.get('/auto-learning/history', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const limit = parseInt(req.query.limit) || 20;
+                const history = this.autoLearningService.getQueryHistory(limit);
+                res.json({
+                    count: history.length,
+                    queries: history
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Local Embedding Routes ====================
+        // Embed text using local model
+        api.post('/embedding/embed', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { text } = req.body;
+                if (!text) {
+                    res.status(400).json({ error: 'text is required' });
+                    return;
+                }
+                const result = await this.localEmbeddingService.embed(text);
+                res.json({
+                    text: result.text,
+                    dimension: result.embedding.length,
+                    embedding: result.embedding.slice(0, 10), // First 10 for preview
+                    model: result.model,
+                    processingTime: result.processingTime
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Calculate similarity
+        api.post('/embedding/similarity', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { text1, text2, method } = req.body;
+                if (!text1 || !text2) {
+                    res.status(400).json({ error: 'text1 and text2 are required' });
+                    return;
+                }
+                const result = await this.localEmbeddingService.similarity(text1, text2, method || 'cosine');
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find most similar texts
+        api.post('/embedding/find-similar', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, candidates, topK } = req.body;
+                if (!query || !candidates || !Array.isArray(candidates)) {
+                    res.status(400).json({ error: 'query and candidates array are required' });
+                    return;
+                }
+                const results = await this.localEmbeddingService.findMostSimilar(query, candidates, topK || 5);
+                res.json({
+                    query,
+                    results
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Web Search Routes ====================
+        // Search and learn from DuckDuckGo
+        api.post('/web-search/search', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, maxResults, learnConcepts, learnRelations, updateCategories } = req.body;
+                if (!query) {
+                    res.status(400).json({ error: 'query is required' });
+                    return;
+                }
+                const result = await this.webSearchService.searchAndLearn(query, {
+                    maxResults: maxResults || 10,
+                    learnConcepts: learnConcepts !== false,
+                    learnRelations: learnRelations !== false,
+                    updateCategories: updateCategories !== false,
+                });
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get category statistics
+        api.get('/web-search/categories', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const stats = await this.webSearchService.getCategoryStats();
+                res.json({
+                    count: stats.length,
+                    categories: stats
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get concepts by category
+        api.get('/web-search/categories/:category/concepts', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { category } = req.params;
+                const limit = parseInt(req.query.limit) || 50;
+                const concepts = await this.webSearchService.getConceptsByCategory(category, limit);
+                res.json({
+                    category,
+                    count: concepts.length,
+                    concepts
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find similar with web search augmentation
+        api.post('/web-search/find-similar', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { concept, topK } = req.body;
+                if (!concept) {
+                    res.status(400).json({ error: 'concept is required' });
+                    return;
+                }
+                const result = await this.webSearchService.findSimilarWithWebSearch(concept, topK || 5);
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get web search stats
+        api.get('/web-search/stats', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const stats = this.webSearchService.getStats();
+                res.json(stats);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Multi-Layer Reasoning Routes ====================
+        // Execute multi-layer reasoning
+        api.post('/reasoning/query', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, maxDepth, minConfidence, useCache } = req.body;
+                if (!query) {
+                    res.status(400).json({ error: 'query is required' });
+                    return;
+                }
+                const result = await this.reasoningEngine.reason(query, {
+                    maxDepth: maxDepth || 3,
+                    minConfidence: minConfidence || 0.5,
+                    useCache: useCache !== false,
+                });
+                res.json(result);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get reasoning stats
+        api.get('/reasoning/stats', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const stats = this.reasoningEngine.getStats();
+                res.json(stats);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Advanced Embedding Routes ====================
+        // Generate advanced embedding (1024d + quantization + PCA)
+        api.post('/advanced-embedding/embed', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { text, quantize, pca } = req.body;
+                if (!text) {
+                    res.status(400).json({ error: 'text is required' });
+                    return;
+                }
+                const result = await this.advancedEmbeddingService.embed(text, {
+                    quantize: quantize !== false,
+                    pca: pca !== false,
+                });
+                res.json({
+                    text: result.text,
+                    dimension: result.dimension,
+                    embedding: result.embedding.slice(0, 10), // Preview
+                    hasQuantized: !!result.quantized,
+                    hasPCA: !!result.pcaEmbedding,
+                    pcaDimension: result.pcaEmbedding?.length,
+                    model: result.model,
+                    processingTime: result.processingTime,
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // 2-stage search: coarse + fine
+        api.post('/advanced-embedding/search', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, candidates, topK } = req.body;
+                if (!query) {
+                    res.status(400).json({ error: 'query is required' });
+                    return;
+                }
+                // If candidates provided, use them; otherwise use empty array
+                const searchCandidates = candidates || [];
+                if (searchCandidates.length === 0) {
+                    res.json({
+                        message: 'No candidates provided for search',
+                        results: []
+                    });
+                    return;
+                }
+                // Coarse search
+                const coarseResults = await this.advancedEmbeddingService.coarseSearch(query, searchCandidates, Math.min(100, searchCandidates.length));
+                // Fine rerank top candidates
+                const topCandidates = coarseResults.slice(0, 20).map(r => {
+                    const candidate = searchCandidates.find((c) => c.id === r.id);
+                    return {
+                        id: r.id,
+                        embedding: Array.isArray(candidate?.embedding) ? candidate.embedding : []
+                    };
+                }).filter(c => c.embedding.length > 0);
+                const fineResults = await this.advancedEmbeddingService.fineRerank(query, topCandidates, topK || 10);
+                res.json({
+                    query,
+                    coarseCount: coarseResults.length,
+                    results: fineResults,
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get advanced embedding stats
+        api.get('/advanced-embedding/stats', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const stats = this.advancedEmbeddingService.getStats();
+                res.json(stats);
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find synonyms from DB
+        api.get('/ontology/synonyms/:word', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const word = req.params.word;
+                // DB-based synonyms
+                const dbSynonyms = await this.ontologyStore.findSynonyms(word);
+                // Embedding-based synonyms (fallback)
+                const embeddingSynonyms = findEmbeddingSynonyms(word);
+                // Combine and deduplicate
+                const allSynonyms = [...new Set([...dbSynonyms, ...embeddingSynonyms])];
+                res.json({
+                    word,
+                    synonyms: allSynonyms,
+                    sources: {
+                        db: dbSynonyms.length,
+                        embedding: embeddingSynonyms.length
+                    }
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get semantic group by word
+        api.get('/ontology/group/:word', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const group = await this.ontologyStore.findGroupByWord(req.params.word);
+                if (!group) {
+                    res.status(404).json({ error: 'Group not found' });
+                    return;
+                }
+                res.json({
+                    id: group.id,
+                    primaryConcept: group.primaryConcept,
+                    synonyms: group.synonyms,
+                    language: group.language,
+                    category: group.category,
+                    frequency: group.frequency,
+                    learnedFrom: group.learnedFrom
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get relations for a concept
+        api.get('/ontology/relations/:concept', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const relations = await this.ontologyStore.getRelations(req.params.concept);
+                res.json({
+                    concept: req.params.concept,
+                    relations: relations.map(r => ({
+                        id: r.id,
+                        source: r.sourceConcept,
+                        target: r.targetConcept,
+                        type: r.type,
+                        weight: r.weight,
+                        learnedFrom: r.learnedFrom
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Get all groups
+        api.get('/ontology/groups', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const category = req.query.category;
+                let groups;
+                if (category) {
+                    groups = await this.ontologyStore.getGroupsByCategory(category);
+                }
+                else {
+                    groups = await this.ontologyStore.getAllGroups();
+                }
+                res.json({
+                    count: groups.length,
+                    groups: groups.map(g => ({
+                        id: g.id,
+                        primary: g.primaryConcept,
+                        synonyms: g.synonyms,
+                        category: g.category,
+                        language: g.language
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Calculate similarity between two words
+        api.get('/ontology/similarity', (req, res, next) => {
+            try {
+                const { word1, word2 } = req.query;
+                if (!word1 || !word2) {
+                    res.status(400).json({ error: 'word1 and word2 are required' });
+                    return;
+                }
+                const similarity = calculateSimilarity(word1, word2);
+                res.json({
+                    word1,
+                    word2,
+                    similarity,
+                    level: similarity >= 0.9 ? 'synonym' :
+                        similarity >= 0.7 ? 'very similar' :
+                            similarity >= 0.5 ? 'similar' :
+                                similarity >= 0.3 ? 'somewhat similar' : 'different'
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Find similar concepts
+        api.post('/ontology/search', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { query, threshold = 0.3, topK = 10 } = req.body;
+                if (!query) {
+                    res.status(400).json({ error: 'query is required' });
+                    return;
+                }
+                // Search in embedding similarity
+                const results = embeddingSimilarity.search(query, threshold, topK);
+                res.json({
+                    query,
+                    count: results.length,
+                    results: results.map(r => ({
+                        concept: r.concept,
+                        similarity: r.similarity
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Ontology stats
+        api.get('/ontology/stats', async (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const stats = await this.ontologyStore.getStats();
+                res.json({
+                    totalGroups: stats.totalGroups,
+                    totalWords: stats.totalWords,
+                    totalRelations: stats.totalRelations,
+                    totalLearnings: stats.totalLearnings,
+                    byCategory: stats.byCategory,
+                    byLanguage: stats.byLanguage
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // ==================== Hierarchical Chunking Routes ====================
+        // Hierarchical chunk - text structure
+        api.post('/hierarchical/chunk', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { text, language } = req.body;
+                if (!text) {
+                    res.status(400).json({ error: 'Text is required' });
+                    return;
+                }
+                const tree = this.hierarchicalChunker.chunk(text, undefined, language || 'auto');
+                const detectedLang = this.hierarchicalChunker.getDetectedLanguage();
+                res.json({
+                    language: detectedLang,
+                    levels: {
+                        document: (tree.levels.get('document') || []).length,
+                        paragraph: (tree.levels.get('paragraph') || []).length,
+                        sentence: (tree.levels.get('sentence') || []).length,
+                        phrase: (tree.levels.get('phrase') || []).length,
+                        word: (tree.levels.get('word') || []).length,
+                        syllable: (tree.levels.get('syllable') || []).length
+                    },
+                    chunks: {
+                        sentences: (tree.levels.get('sentence') || []).map(c => c.text),
+                        phrases: (tree.levels.get('phrase') || []).map(c => c.text),
+                        words: (tree.levels.get('word') || []).map(c => c.text),
+                        syllables: (tree.levels.get('syllable') || []).map(c => c.text)
+                    }
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Analyze text with multi-lang tokenizer
+        api.post('/hierarchical/analyze', (req, res, next) => {
+            try {
+                this.ensureInitialized();
+                const { text } = req.body;
+                if (!text) {
+                    res.status(400).json({ error: 'Text is required' });
+                    return;
+                }
+                const analysis = multiLangTokenizer.analyze(text);
+                res.json({
+                    language: analysis.language,
+                    sentences: analysis.sentences,
+                    phrases: analysis.phrases,
+                    words: analysis.words,
+                    morphemes: analysis.morphemes,
+                    tokens: analysis.tokens.map(t => ({
+                        text: t.text,
+                        type: t.type
+                    }))
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Detect language
+        api.post('/hierarchical/detect-language', (req, res, next) => {
+            try {
+                const { text } = req.body;
+                if (!text) {
+                    res.status(400).json({ error: 'Text is required' });
+                    return;
+                }
+                const language = detectLanguage(text);
+                const languageNames = {
+                    ko: '한국어',
+                    en: 'English',
+                    ja: '日本語',
+                    zh: '中文',
+                    auto: 'Auto-detected'
+                };
+                res.json({
+                    text: text.slice(0, 100),
+                    language,
+                    languageName: languageNames[language] || language
+                });
+            }
+            catch (err) {
+                next(err);
+            }
+        });
+        // Mount API routes
+        this.app.use('/api/v1', api);
+        // Serve React dashboard build
+        const dashboardPath = path.join(__dirname, '../../dashboard/dist');
+        const publicPath = path.join(__dirname, '../../public');
+        // Try dashboard build first, fallback to public
+        this.app.use(express.static(dashboardPath));
+        this.app.use(express.static(publicPath));
+        // SPA fallback - serve index.html for non-API routes
+        this.app.get('*', (req, res, next) => {
+            // Skip API routes
+            if (req.path.startsWith('/api/')) {
+                return next();
+            }
+            // Try dashboard build first
+            const dashboardIndex = path.join(dashboardPath, 'index.html');
+            const publicIndex = path.join(publicPath, 'index.html');
+            if (fs.existsSync(dashboardIndex)) {
+                res.sendFile(dashboardIndex);
+            }
+            else if (fs.existsSync(publicIndex)) {
+                res.sendFile(publicIndex);
+            }
+            else {
+                next();
+            }
+        });
+    }
+    /**
+     * Setup error handling
+     */
+    setupErrorHandling() {
+        // Error logger middleware
+        this.app.use(errorLogger);
+        // 404 handler for API routes
+        this.app.use((_req, res) => {
+            res.status(404).json({
+                error: 'Not Found',
+                message: 'The requested resource was not found',
+            });
+        });
+        // Error handler - hide details in production
+        this.app.use((err, _req, res, _next) => {
+            const isProduction = process.env.NODE_ENV === 'production';
+            // Log full error internally
+            logger.error('Unhandled error', {
+                message: err.message,
+                stack: isProduction ? undefined : err.stack,
+            });
+            // Send sanitized response
+            res.status(500).json({
+                error: 'Internal Server Error',
+                message: isProduction
+                    ? 'An unexpected error occurred. Please try again later.'
+                    : err.message,
+            });
+        });
+    }
+    /**
+     * Ensure server is initialized
+     */
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('Server not initialized');
+        }
+    }
+    /**
+     * Get Express app instance
+     */
+    getApp() {
+        return this.app;
+    }
+}
+/**
+ * Create and start NMT server
+ */
+export async function createServer(options) {
+    const server = new NMTServer(options);
+    await server.start();
+    return server;
+}
+//# sourceMappingURL=server.js.map