titan-synapse 0.1.1

package/crates/synapse/src/openai.rs

@@ -0,0 +1,232 @@
+use axum::{
+    Json,
+    extract::State,
+    response::{IntoResponse, Response},
+};
+use serde::{Deserialize, Serialize};
+
+use crate::server::SharedState;
+use crate::streaming;
+use crate::memory::{KnowledgeExtractor, HallucinationDetector};
+
+#[derive(Debug, Deserialize)]
+pub struct ChatCompletionRequest {
+    pub model: Option<String>,
+    pub messages: Vec<Message>,
+    #[serde(default)]
+    pub temperature: Option<f32>,
+    #[serde(default)]
+    pub top_p: Option<f32>,
+    #[serde(default)]
+    pub max_tokens: Option<u32>,
+    #[serde(default)]
+    pub stream: Option<bool>,
+    #[serde(default)]
+    pub stop: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Message {
+    pub role: String,
+    pub content: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ChatCompletionResponse {
+    pub id: String,
+    pub object: String,
+    pub created: i64,
+    pub model: String,
+    pub choices: Vec<Choice>,
+    pub usage: Usage,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Choice {
+    pub index: u32,
+    pub message: Message,
+    pub finish_reason: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Usage {
+    pub prompt_tokens: u32,
+    pub completion_tokens: u32,
+    pub total_tokens: u32,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ChatCompletionChunk {
+    pub id: String,
+    pub object: String,
+    pub created: i64,
+    pub model: String,
+    pub choices: Vec<ChunkChoice>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ChunkChoice {
+    pub index: u32,
+    pub delta: Delta,
+    pub finish_reason: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Delta {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub role: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ModelList {
+    pub object: String,
+    pub data: Vec<ModelInfo>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ModelInfo {
+    pub id: String,
+    pub object: String,
+    pub created: i64,
+    pub owned_by: String,
+}
+
+pub async fn chat_completions(
+    State(state): State<SharedState>,
+    Json(request): Json<ChatCompletionRequest>,
+) -> Response {
+    let is_stream = request.stream.unwrap_or(false);
+
+    if is_stream {
+        streaming::stream_response(state, request).await.into_response()
+    } else {
+        complete_response(state, request).await.into_response()
+    }
+}
+
+async fn complete_response(
+    state: SharedState,
+    request: ChatCompletionRequest,
+) -> Json<ChatCompletionResponse> {
+    let state = state.read().await;
+    let model_name = request.model.clone().unwrap_or_else(|| state.config.base_model.clone());
+
+    // Log the user message
+    let session_id = uuid::Uuid::new_v4().to_string();
+    if let Some(last_msg) = request.messages.last() {
+        let _ = state.knowledge.log_message(&session_id, &last_msg.role, &last_msg.content, None);
+    }
+
+    // Route through orchestrator with Hebbian routing
+    let result = state.orchestrator.process(
+        &request.messages,
+        &state.engine,
+        request.max_tokens,
+        request.temperature,
+        Some(&state.knowledge),
+    ).await;
+
+    let (response_text, usage) = match result {
+        Ok(result) => {
+            // Log the assistant response
+            let _ = state.knowledge.log_message(&session_id, "assistant", &result.text, None);
+
+            // Extract knowledge from the response (real-time learning)
+            let _ = KnowledgeExtractor::extract_and_store(
+                &state.knowledge, &result.text, "assistant",
+            );
+
+            // Check for user feedback patterns (preference learning)
+            if request.messages.len() >= 2 {
+                let prev_assistant = request.messages.iter().rev()
+                    .find(|m| m.role == "assistant")
+                    .map(|m| m.content.as_str())
+                    .unwrap_or("");
+                if let Some(user_msg) = request.messages.last() {
+                    let _ = KnowledgeExtractor::extract_preferences(
+                        &state.knowledge, &user_msg.content, prev_assistant, "general",
+                    );
+                }
+            }
+
+            // Verify response against knowledge graph (hallucination detection)
+            let verification = HallucinationDetector::verify(&state.knowledge, &result.text);
+            if let Ok(ref v) = verification {
+                if !v.contradictions.is_empty() {
+                    tracing::warn!(
+                        "⚠️ Hallucination detected: {} contradictions in response",
+                        v.contradictions.len()
+                    );
+                }
+                tracing::debug!(
+                    "Verification: {:.0}% confidence, {} verified, {} unverified, {} contradictions",
+                    v.confidence * 100.0,
+                    v.verified_claims.len(),
+                    v.unverified_claims.len(),
+                    v.contradictions.len()
+                );
+            }
+
+            (result.text, Usage {
+                prompt_tokens: result.prompt_tokens,
+                completion_tokens: result.completion_tokens,
+                total_tokens: result.total_tokens,
+            })
+        }
+        Err(e) => (format!("Error: {e}"), Usage {
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0,
+        }),
+    };
+
+    let response = ChatCompletionResponse {
+        id: format!("chatcmpl-{}", uuid::Uuid::new_v4()),
+        object: "chat.completion".into(),
+        created: chrono::Utc::now().timestamp(),
+        model: model_name,
+        choices: vec![Choice {
+            index: 0,
+            message: Message {
+                role: "assistant".into(),
+                content: response_text,
+            },
+            finish_reason: "stop".into(),
+        }],
+        usage,
+    };
+
+    Json(response)
+}
+
+pub async fn list_models(
+    State(state): State<SharedState>,
+) -> Json<ModelList> {
+    let state = state.read().await;
+
+    let mut models = vec![
+        ModelInfo {
+            id: "synapse".into(),
+            object: "model".into(),
+            created: chrono::Utc::now().timestamp(),
+            owned_by: "titan-synapse".into(),
+        },
+    ];
+
+    // Add each specialist as a model
+    for specialist in &state.config.specialists {
+        models.push(ModelInfo {
+            id: format!("synapse/{}", specialist.name),
+            object: "model".into(),
+            created: chrono::Utc::now().timestamp(),
+            owned_by: "titan-synapse".into(),
+        });
+    }
+
+    Json(ModelList {
+        object: "list".into(),
+        data: models,
+    })
+}

package/crates/synapse/src/server.rs

@@ -0,0 +1,166 @@
+use anyhow::Result;
+use axum::{
+    Router,
+    routing::{get, post},
+};
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use tower_http::cors::CorsLayer;
+use tower_http::trace::TraceLayer;
+
+use crate::config::SynapseConfig;
+use crate::inference::InferenceEngine;
+use crate::swarm::Orchestrator;
+use crate::memory::KnowledgeGraph;
+
+pub struct AppState {
+    pub config: SynapseConfig,
+    pub engine: InferenceEngine,
+    pub orchestrator: Orchestrator,
+    pub knowledge: KnowledgeGraph,
+}
+
+pub type SharedState = Arc<RwLock<AppState>>;
+
+pub async fn run(config: SynapseConfig, port: u16) -> Result<()> {
+    tracing::info!("Starting TITAN Synapse on port {port}");
+
+    let knowledge = KnowledgeGraph::new(&config.data_dir.join("knowledge.db"))?;
+    let engine = InferenceEngine::new(&config)?;
+    let orchestrator = Orchestrator::new(&config);
+
+    let state: SharedState = Arc::new(RwLock::new(AppState {
+        config: config.clone(),
+        engine,
+        orchestrator,
+        knowledge,
+    }));
+
+    let app = Router::new()
+        // Web Dashboard — normal people can open a browser and chat
+        .route("/", get(dashboard))
+        // OpenAI-compatible endpoints
+        .route("/v1/chat/completions", post(crate::openai::chat_completions))
+        .route("/v1/models", get(crate::openai::list_models))
+        // Health
+        .route("/health", get(health))
+        // Status + Metacognition
+        .route("/api/status", get(api_status))
+        .route("/api/confidence", get(api_confidence))
+        // Adapter management
+        .route("/api/adapters/reload", post(api_reload_adapters))
+        .layer(CorsLayer::permissive())
+        .layer(TraceLayer::new_for_http())
+        .with_state(state);
+
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{port}")).await?;
+    tracing::info!("TITAN Synapse ready at http://0.0.0.0:{port}");
+    tracing::info!("Dashboard: http://0.0.0.0:{port}/");
+    tracing::info!("OpenAI-compatible API: http://0.0.0.0:{port}/v1/chat/completions");
+
+    axum::serve(listener, app)
+        .with_graceful_shutdown(shutdown_signal())
+        .await?;
+
+    Ok(())
+}
+
+async fn dashboard() -> axum::response::Html<&'static str> {
+    axum::response::Html(crate::dashboard::DASHBOARD_HTML)
+}
+
+async fn health() -> &'static str {
+    "ok"
+}
+
+async fn api_status(
+    state: axum::extract::State<SharedState>,
+) -> axum::Json<serde_json::Value> {
+    let state = state.read().await;
+
+    let fact_count = state.knowledge.fact_count().unwrap_or(0);
+    let top_pathways = state.knowledge.top_pathways(5).unwrap_or_default();
+
+    axum::Json(serde_json::json!({
+        "status": "running",
+        "version": env!("CARGO_PKG_VERSION"),
+        "engine": "synapse",
+        "models_loaded": state.engine.loaded_models(),
+        "has_models": state.engine.has_models(),
+        "specialists": state.config.specialists.iter().map(|s| &s.name).collect::<Vec<_>>(),
+        "adapters": state.engine.available_adapters(),
+        "coordinator": state.config.coordinator_model,
+        "base_model": state.config.base_model,
+        "knowledge": {
+            "facts": fact_count,
+            "conversations": state.knowledge.conversation_count().unwrap_or(0),
+            "preference_pairs": state.knowledge.total_preference_count().unwrap_or(0),
+        },
+        "hebbian_routing": {
+            "top_pathways": top_pathways.iter().map(|(p, s, avg)| {
+                serde_json::json!({"pathway": p, "strength": s, "avg_score": avg})
+            }).collect::<Vec<_>>(),
+        },
+    }))
+}
+
+/// Metacognitive confidence report — what the system knows it's good (and bad) at
+async fn api_confidence(
+    state: axum::extract::State<SharedState>,
+) -> axum::Json<serde_json::Value> {
+    let state = state.read().await;
+
+    let specialist_confidence = state.knowledge.specialist_confidence_report().unwrap_or_default();
+    let pathways = state.knowledge.top_pathways(10).unwrap_or_default();
+
+    axum::Json(serde_json::json!({
+        "metacognition": {
+            "description": "Specialist confidence scores — the system knows what it knows",
+            "specialists": specialist_confidence,
+            "hebbian_pathways": pathways.iter().map(|(p, s, avg)| {
+                serde_json::json!({
+                    "pathway": p,
+                    "strength": s,
+                    "avg_score": avg,
+                    "description": format!("Pathway {} has been reinforced {} times", p, s)
+                })
+            }).collect::<Vec<_>>(),
+            "total_pathways": pathways.len(),
+            "learning_status": {
+                "preferences_collected": state.knowledge.total_preference_count().unwrap_or(0),
+                "conversations_logged": state.knowledge.conversation_count().unwrap_or(0),
+                "facts_known": state.knowledge.fact_count().unwrap_or(0),
+            }
+        }
+    }))
+}
+
+/// Reload LoRA adapters from disk — picks up newly trained adapters without restart
+async fn api_reload_adapters(
+    state: axum::extract::State<SharedState>,
+) -> axum::Json<serde_json::Value> {
+    let mut state = state.write().await;
+    match state.engine.reload_adapters() {
+        Ok(count) => {
+            tracing::info!("Reloaded adapters: {count} found");
+            axum::Json(serde_json::json!({
+                "status": "ok",
+                "adapters_loaded": count,
+                "adapters": state.engine.available_adapters(),
+            }))
+        }
+        Err(e) => {
+            axum::Json(serde_json::json!({
+                "status": "error",
+                "error": e.to_string(),
+            }))
+        }
+    }
+}
+
+async fn shutdown_signal() {
+    tokio::signal::ctrl_c()
+        .await
+        .expect("failed to install CTRL+C signal handler");
+    tracing::info!("Shutting down TITAN Synapse...");
+}

package/crates/synapse/src/streaming.rs

@@ -0,0 +1,80 @@
+use axum::response::sse::{Event, Sse};
+use axum::response::IntoResponse;
+use futures::stream::{self, Stream};
+use std::convert::Infallible;
+
+use crate::openai::{ChatCompletionChunk, ChatCompletionRequest, ChunkChoice, Delta};
+use crate::server::SharedState;
+
+pub async fn stream_response(
+    state: SharedState,
+    request: ChatCompletionRequest,
+) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
+    let state_read = state.read().await;
+    let model_name = request.model.clone().unwrap_or_else(|| state_read.config.base_model.clone());
+
+    // Generate full response, then stream it token-by-token
+    // In production, this will be replaced with true streaming from the inference engine
+    let response_text = match state_read.orchestrator.process(
+        &request.messages,
+        &state_read.engine,
+        request.max_tokens,
+        request.temperature,
+        Some(&state_read.knowledge),
+    ).await {
+        Ok(result) => result.text,
+        Err(e) => format!("Error: {e}"),
+    };
+    drop(state_read);
+
+    let id = format!("chatcmpl-{}", uuid::Uuid::new_v4());
+    let created = chrono::Utc::now().timestamp();
+
+    // Split into word-level chunks for streaming effect
+    let words: Vec<String> = response_text.split_inclusive(' ')
+        .map(|s| s.to_string())
+        .collect();
+
+    let stream = stream::iter(
+        // First chunk: role
+        std::iter::once(Ok(Event::default().data(
+            serde_json::to_string(&ChatCompletionChunk {
+                id: id.clone(),
+                object: "chat.completion.chunk".into(),
+                created,
+                model: model_name.clone(),
+                choices: vec![ChunkChoice {
+                    index: 0,
+                    delta: Delta {
+                        role: Some("assistant".into()),
+                        content: None,
+                    },
+                    finish_reason: None,
+                }],
+            }).unwrap()
+        )))
+        // Content chunks
+        .chain(words.into_iter().map(move |word| {
+            Ok(Event::default().data(
+                serde_json::to_string(&ChatCompletionChunk {
+                    id: id.clone(),
+                    object: "chat.completion.chunk".into(),
+                    created,
+                    model: model_name.clone(),
+                    choices: vec![ChunkChoice {
+                        index: 0,
+                        delta: Delta {
+                            role: None,
+                            content: Some(word),
+                        },
+                        finish_reason: None,
+                    }],
+                }).unwrap()
+            ))
+        }))
+        // Final chunk: [DONE]
+        .chain(std::iter::once(Ok(Event::default().data("[DONE]"))))
+    );
+
+    Sse::new(stream)
+}

package/crates/synapse/src/swarm/coordinator.rs

@@ -0,0 +1,198 @@
+use crate::config::SynapseConfig;
+use crate::memory::KnowledgeGraph;
+use super::orchestrator::{RoutingDecision, SubTask};
+
+/// Coordinator — routes requests to the right specialist(s)
+/// Uses Hebbian routing: pathways that fire together, wire together
+/// Includes metacognitive confidence scoring
+pub struct Coordinator {
+    /// Keyword → specialist mapping (will be replaced by learned routing)
+    keyword_routes: Vec<(Vec<String>, String)>,
+}
+
+impl Coordinator {
+    pub fn new(config: &SynapseConfig) -> Self {
+        let mut keyword_routes = Vec::new();
+
+        for specialist in &config.specialists {
+            keyword_routes.push((
+                specialist.capabilities.clone(),
+                specialist.name.clone(),
+            ));
+        }
+
+        Self {
+            keyword_routes,
+        }
+    }
+
+    /// Route a query to the appropriate specialist(s)
+    /// Returns routing decision with metacognitive confidence score
+    pub fn route(&self, query: &str, knowledge: Option<&KnowledgeGraph>) -> RoutingDecision {
+        let query_lower = query.to_lowercase();
+        let words: Vec<&str> = query_lower.split_whitespace().collect();
+
+        // Score each specialist based on keyword matches
+        let mut scores: Vec<(String, f32)> = self.keyword_routes.iter()
+            .map(|(keywords, name)| {
+                let keyword_matches = keywords.iter()
+                    .filter(|kw| words.iter().any(|w| w.contains(kw.as_str())))
+                    .count() as f32;
+
+                // Normalize by total keywords — more specific matches = higher confidence
+                let keyword_ratio = if keywords.is_empty() {
+                    0.0
+                } else {
+                    keyword_matches / keywords.len() as f32
+                };
+
+                // Base confidence: keyword match ratio (0.0 - 1.0)
+                let confidence = keyword_matches + keyword_ratio * 2.0;
+                (name.clone(), confidence)
+            })
+            .filter(|(_, score)| *score > 0.0)
+            .collect();
+
+        scores.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
+
+        // Boost scores using Hebbian pathway strengths from the knowledge graph
+        if let Some(kg) = knowledge {
+            for (name, score) in &mut scores {
+                let pathway = vec![name.clone()];
+                if let Ok(strength) = kg.pathway_strength(&pathway) {
+                    // Add pathway strength as bonus (clamped to reasonable range)
+                    *score += (strength.min(10.0) as f32) * 0.5;
+                }
+            }
+            scores.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
+        }
+
+        // Detect complexity indicators for swarm mode
+        let complexity_keywords = ["and", "also", "plus", "then", "after", "build", "create", "implement"];
+        let complexity = complexity_keywords.iter()
+            .filter(|kw| query_lower.contains(*kw))
+            .count();
+
+        // Calculate confidence — how sure are we about the routing?
+        let top_confidence = scores.first().map(|(_, s)| *s).unwrap_or(0.0);
+        let second_confidence = scores.get(1).map(|(_, s)| *s).unwrap_or(0.0);
+        let confidence_gap = if second_confidence > 0.0 {
+            (top_confidence - second_confidence) / top_confidence
+        } else if top_confidence > 0.0 {
+            1.0  // Only one match — high confidence
+        } else {
+            0.0  // No matches — low confidence, use general
+        };
+
+        // Normalize to 0-5 scale for pathway reinforcement
+        let routing_confidence = (top_confidence.min(5.0)).max(1.0);
+
+        if complexity >= 2 && scores.len() >= 2 {
+            // Complex query — use swarm with parallel execution
+            let subtasks: Vec<SubTask> = scores.iter()
+                .take(3)
+                .map(|(specialist, _)| SubTask {
+                    specialist: specialist.clone(),
+                    description: format!("Handle {specialist} aspects of: {query}"),
+                })
+                .collect();
+
+            RoutingDecision::Swarm { subtasks }
+        } else if let Some((specialist, _)) = scores.first() {
+            RoutingDecision::Single {
+                specialist: specialist.clone(),
+                confidence: routing_confidence,
+            }
+        } else {
+            // Default to general specialist — low confidence
+            RoutingDecision::Single {
+                specialist: "general".into(),
+                confidence: 1.0,
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::{SynapseConfig, SpecialistConfig};
+
+    fn test_config() -> SynapseConfig {
+        let mut config = SynapseConfig::default();
+        config.specialists = vec![
+            SpecialistConfig {
+                name: "python_expert".into(),
+                capabilities: vec!["python".into(), "decorator".into(), "django".into(), "flask".into()],
+                base_model: None,
+                adapter: None,
+                system_prompt: None,
+                priority: 60,
+            },
+            SpecialistConfig {
+                name: "sql_expert".into(),
+                capabilities: vec!["sql".into(), "database".into(), "query".into(), "postgres".into()],
+                base_model: None,
+                adapter: None,
+                system_prompt: None,
+                priority: 60,
+            },
+            SpecialistConfig {
+                name: "devops_expert".into(),
+                capabilities: vec!["docker".into(), "kubernetes".into(), "deploy".into(), "ci".into()],
+                base_model: None,
+                adapter: None,
+                system_prompt: None,
+                priority: 60,
+            },
+        ];
+        config
+    }
+
+    #[test]
+    fn test_single_routing() {
+        let config = test_config();
+        let coordinator = Coordinator::new(&config);
+
+        let decision = coordinator.route("What is a Python decorator?", None);
+        match decision {
+            RoutingDecision::Single { specialist, confidence } => {
+                assert_eq!(specialist, "python_expert");
+                assert!(confidence >= 1.0);
+            }
+            _ => panic!("Expected single routing"),
+        }
+    }
+
+    #[test]
+    fn test_swarm_routing() {
+        let config = test_config();
+        let coordinator = Coordinator::new(&config);
+
+        let decision = coordinator.route(
+            "Build a Python API and deploy it with Docker and also create the database",
+            None,
+        );
+        match decision {
+            RoutingDecision::Swarm { subtasks } => {
+                assert!(subtasks.len() >= 2, "Should route to multiple specialists");
+            }
+            _ => panic!("Expected swarm routing for complex query"),
+        }
+    }
+
+    #[test]
+    fn test_default_routing() {
+        let config = test_config();
+        let coordinator = Coordinator::new(&config);
+
+        let decision = coordinator.route("What is the meaning of life?", None);
+        match decision {
+            RoutingDecision::Single { specialist, confidence } => {
+                assert_eq!(specialist, "general");
+                assert_eq!(confidence, 1.0);
+            }
+            _ => panic!("Expected default general routing"),
+        }
+    }
+}

package/crates/synapse/src/swarm/mod.rs

@@ -0,0 +1,8 @@
+pub mod orchestrator;
+pub mod coordinator;
+pub mod pool;
+pub mod synthesizer;
+pub mod spawner;
+
+pub use orchestrator::Orchestrator;
+pub use spawner::SpecialistSpawner;