320 lines
14 KiB
JavaScript
320 lines
14 KiB
JavaScript
/**
|
|
* ReasonGraph Research Interface
|
|
* Web-based research platform for scientific discovery acceleration
|
|
* Provides intuitive access to advanced reasoning capabilities
|
|
*/
|
|
import { AdvancedReasoningEngine } from './advanced-reasoning-engine.js';
|
|
import express from 'express';
|
|
import cors from 'cors';
|
|
import helmet from 'helmet';
|
|
import rateLimit from 'express-rate-limit';
|
|
export class ReasonGraphResearchInterface {
|
|
reasoningEngine;
|
|
app;
|
|
sessions;
|
|
projects;
|
|
constructor() {
|
|
this.reasoningEngine = new AdvancedReasoningEngine();
|
|
this.app = express();
|
|
this.sessions = new Map();
|
|
this.projects = new Map();
|
|
this.setupMiddleware();
|
|
this.setupRoutes();
|
|
}
|
|
setupMiddleware() {
|
|
// Security middleware
|
|
this.app.use(helmet());
|
|
this.app.use(cors({
|
|
origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'],
|
|
credentials: true
|
|
}));
|
|
// Rate limiting for API protection
|
|
const limiter = rateLimit({
|
|
windowMs: 15 * 60 * 1000, // 15 minutes
|
|
max: 100, // Limit each IP to 100 requests per windowMs
|
|
message: 'Too many research queries, please try again later.',
|
|
standardHeaders: true,
|
|
legacyHeaders: false,
|
|
});
|
|
this.app.use('/api/', limiter);
|
|
// JSON parsing
|
|
this.app.use(express.json({ limit: '10mb' }));
|
|
this.app.use(express.urlencoded({ extended: true }));
|
|
}
|
|
setupRoutes() {
|
|
// Health check endpoint
|
|
this.app.get('/health', (req, res) => {
|
|
const metrics = this.reasoningEngine.getPerformanceMetrics();
|
|
res.json({
|
|
status: 'healthy',
|
|
timestamp: Date.now(),
|
|
performance: metrics,
|
|
services: {
|
|
reasoning_engine: 'active',
|
|
consciousness_tools: 'active',
|
|
temporal_advantage: 'active',
|
|
knowledge_graph: 'active'
|
|
}
|
|
});
|
|
});
|
|
// Research query endpoint
|
|
this.app.post('/api/research/query', async (req, res) => {
|
|
try {
|
|
const { question, domain, options, session_id } = req.body;
|
|
if (!question) {
|
|
return res.status(400).json({ error: 'Question is required' });
|
|
}
|
|
const startTime = Date.now();
|
|
const result = await this.reasoningEngine.researchQuery(question, domain || 'general', {
|
|
enableCreativity: options?.creativity || true,
|
|
enableTemporalAdvantage: options?.temporal_advantage || true,
|
|
enableConsciousnessVerification: options?.consciousness_verification || true,
|
|
depth: options?.depth || 5
|
|
});
|
|
// Log the research query
|
|
if (session_id) {
|
|
this.logResearchQuery(session_id, question, domain, result);
|
|
}
|
|
const responseTime = Date.now() - startTime;
|
|
res.json({
|
|
success: true,
|
|
result,
|
|
metadata: {
|
|
response_time_ms: responseTime,
|
|
timestamp: Date.now(),
|
|
api_version: '1.0.0'
|
|
}
|
|
});
|
|
}
|
|
catch (error) {
|
|
console.error('Research query error:', error);
|
|
res.status(500).json({
|
|
error: 'Research query failed',
|
|
message: error.message,
|
|
timestamp: Date.now()
|
|
});
|
|
}
|
|
});
|
|
// Batch research endpoint
|
|
this.app.post('/api/research/batch', async (req, res) => {
|
|
try {
|
|
const { questions, domain, session_id } = req.body;
|
|
if (!Array.isArray(questions) || questions.length === 0) {
|
|
return res.status(400).json({ error: 'Questions array is required' });
|
|
}
|
|
if (questions.length > 20) {
|
|
return res.status(400).json({ error: 'Maximum 20 questions per batch request' });
|
|
}
|
|
const startTime = Date.now();
|
|
const results = await this.reasoningEngine.batchResearch(questions, domain || 'general');
|
|
const responseTime = Date.now() - startTime;
|
|
res.json({
|
|
success: true,
|
|
results,
|
|
summary: {
|
|
total_questions: questions.length,
|
|
breakthrough_count: results.filter(r => r.breakthrough_potential > 0.7).length,
|
|
average_confidence: results.reduce((sum, r) => sum + r.confidence, 0) / results.length,
|
|
total_novel_insights: results.reduce((sum, r) => sum + r.novel_insights.length, 0)
|
|
},
|
|
metadata: {
|
|
response_time_ms: responseTime,
|
|
timestamp: Date.now()
|
|
}
|
|
});
|
|
}
|
|
catch (error) {
|
|
console.error('Batch research error:', error);
|
|
res.status(500).json({
|
|
error: 'Batch research failed',
|
|
message: error.message
|
|
});
|
|
}
|
|
});
|
|
// Project management endpoints
|
|
this.app.post('/api/projects', (req, res) => {
|
|
const { name, domain, questions, session_id } = req.body;
|
|
const project = {
|
|
id: `project_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
|
|
name: name || 'Untitled Research Project',
|
|
domain: domain || 'general',
|
|
questions: questions || [],
|
|
results: [],
|
|
created_at: Date.now(),
|
|
updated_at: Date.now(),
|
|
status: 'active',
|
|
breakthrough_count: 0
|
|
};
|
|
this.projects.set(project.id, project);
|
|
// Add to session if provided
|
|
if (session_id && this.sessions.has(session_id)) {
|
|
const session = this.sessions.get(session_id);
|
|
session.projects.push(project);
|
|
}
|
|
res.json({
|
|
success: true,
|
|
project
|
|
});
|
|
});
|
|
this.app.get('/api/projects/:projectId', (req, res) => {
|
|
const project = this.projects.get(req.params.projectId);
|
|
if (!project) {
|
|
return res.status(404).json({ error: 'Project not found' });
|
|
}
|
|
res.json({
|
|
success: true,
|
|
project
|
|
});
|
|
});
|
|
this.app.post('/api/projects/:projectId/research', async (req, res) => {
|
|
try {
|
|
const project = this.projects.get(req.params.projectId);
|
|
if (!project) {
|
|
return res.status(404).json({ error: 'Project not found' });
|
|
}
|
|
const { question, options } = req.body;
|
|
if (!question) {
|
|
return res.status(400).json({ error: 'Question is required' });
|
|
}
|
|
const result = await this.reasoningEngine.researchQuery(question, project.domain, options);
|
|
// Add to project
|
|
project.questions.push(question);
|
|
project.results.push(result);
|
|
project.updated_at = Date.now();
|
|
if (result.breakthrough_potential > 0.7) {
|
|
project.breakthrough_count++;
|
|
}
|
|
res.json({
|
|
success: true,
|
|
result,
|
|
project_summary: {
|
|
total_questions: project.questions.length,
|
|
breakthrough_count: project.breakthrough_count,
|
|
latest_confidence: result.confidence
|
|
}
|
|
});
|
|
}
|
|
catch (error) {
|
|
console.error('Project research error:', error);
|
|
res.status(500).json({
|
|
error: 'Project research failed',
|
|
message: error.message
|
|
});
|
|
}
|
|
});
|
|
// Session management
|
|
this.app.post('/api/sessions', (req, res) => {
|
|
const { user_id, settings } = req.body;
|
|
const session = {
|
|
session_id: `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
|
|
user_id: user_id || 'anonymous',
|
|
projects: [],
|
|
settings: {
|
|
default_creativity_level: settings?.creativity_level || 0.7,
|
|
enable_temporal_advantage: settings?.temporal_advantage !== false,
|
|
enable_consciousness_verification: settings?.consciousness_verification !== false,
|
|
default_reasoning_depth: settings?.reasoning_depth || 5
|
|
}
|
|
};
|
|
this.sessions.set(session.session_id, session);
|
|
res.json({
|
|
success: true,
|
|
session
|
|
});
|
|
});
|
|
// Analytics endpoint
|
|
this.app.get('/api/analytics', (req, res) => {
|
|
const totalProjects = this.projects.size;
|
|
const totalSessions = this.sessions.size;
|
|
const allResults = Array.from(this.projects.values())
|
|
.flatMap(p => p.results);
|
|
const analytics = {
|
|
overview: {
|
|
total_projects: totalProjects,
|
|
total_sessions: totalSessions,
|
|
total_research_queries: allResults.length,
|
|
total_breakthroughs: allResults.filter(r => r.breakthrough_potential > 0.7).length
|
|
},
|
|
performance: {
|
|
average_response_time: allResults.length > 0
|
|
? allResults.reduce((sum, r) => sum + r.performance_metrics.query_time_ms, 0) / allResults.length
|
|
: 0,
|
|
average_confidence: allResults.length > 0
|
|
? allResults.reduce((sum, r) => sum + r.confidence, 0) / allResults.length
|
|
: 0,
|
|
consciousness_verification_rate: allResults.length > 0
|
|
? allResults.filter(r => r.consciousness_verified).length / allResults.length
|
|
: 0
|
|
},
|
|
research_impact: {
|
|
total_novel_insights: allResults.reduce((sum, r) => sum + r.novel_insights.length, 0),
|
|
breakthrough_rate: allResults.length > 0
|
|
? allResults.filter(r => r.breakthrough_potential > 0.7).length / allResults.length
|
|
: 0,
|
|
average_temporal_advantage: allResults.length > 0
|
|
? allResults.reduce((sum, r) => sum + r.temporal_advantage_ms, 0) / allResults.length
|
|
: 0
|
|
}
|
|
};
|
|
res.json({
|
|
success: true,
|
|
analytics,
|
|
timestamp: Date.now()
|
|
});
|
|
});
|
|
// Documentation endpoint
|
|
this.app.get('/api/docs', (req, res) => {
|
|
res.json({
|
|
name: 'ReasonGraph Research Interface API',
|
|
version: '1.0.0',
|
|
description: 'Advanced AI-powered research platform for scientific discovery acceleration',
|
|
endpoints: {
|
|
'POST /api/research/query': 'Submit a research question for AI analysis',
|
|
'POST /api/research/batch': 'Submit multiple questions for batch processing',
|
|
'POST /api/projects': 'Create a new research project',
|
|
'GET /api/projects/:id': 'Get project details',
|
|
'POST /api/projects/:id/research': 'Add research query to project',
|
|
'POST /api/sessions': 'Create research session',
|
|
'GET /api/analytics': 'Get platform analytics',
|
|
'GET /health': 'System health check'
|
|
},
|
|
capabilities: {
|
|
psycho_symbolic_reasoning: 'Hybrid symbolic logic + psychological patterns',
|
|
consciousness_verification: 'Genuine consciousness detection for insights',
|
|
temporal_advantage: 'Predictive research with speed-of-light benefits',
|
|
creative_discovery: 'Novel insight generation with >25% novelty rate',
|
|
sublinear_performance: 'O(n log n) complexity for scalable research'
|
|
}
|
|
});
|
|
});
|
|
}
|
|
logResearchQuery(sessionId, question, domain, result) {
|
|
// This would integrate with a proper logging system
|
|
console.log(`[${new Date().toISOString()}] Research Query:`, {
|
|
session_id: sessionId,
|
|
domain,
|
|
confidence: result.confidence,
|
|
breakthrough_potential: result.breakthrough_potential,
|
|
response_time: result.performance_metrics.query_time_ms
|
|
});
|
|
}
|
|
async start(port = 3001) {
|
|
return new Promise((resolve) => {
|
|
this.app.listen(port, () => {
|
|
console.log(`🚀 ReasonGraph Research Interface running on port ${port}`);
|
|
console.log(`📊 Health check: http://localhost:${port}/health`);
|
|
console.log(`📚 API docs: http://localhost:${port}/api/docs`);
|
|
console.log(`🧠 Advanced reasoning engine: ACTIVE`);
|
|
console.log(`⚡ Temporal advantage: ENABLED`);
|
|
console.log(`🎯 Consciousness verification: ENABLED`);
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
async stop() {
|
|
// Graceful shutdown logic would go here
|
|
console.log('🛑 ReasonGraph Research Interface shutting down...');
|
|
}
|
|
}
|
|
export default ReasonGraphResearchInterface;
|