titan-synapse 0.1.1

package/crates/synapse/src/learn/engine.rs

@@ -0,0 +1,109 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+/// Bridge to the Python learning sidecar
+pub struct LearningEngine {
+    sidecar_url: String,
+    enabled: bool,
+    client: reqwest::Client,
+}
+
+#[derive(Debug, Serialize)]
+pub struct EvalRequest {
+    pub specialist: String,
+    pub prompt: String,
+    pub response: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct EvalResponse {
+    pub score: f32,
+    pub improved_response: Option<String>,
+    pub feedback: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct TrainRequest {
+    pub specialist: String,
+    pub base_model: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct TrainResponse {
+    pub adapter_path: String,
+    pub loss: f32,
+    pub pairs_used: u32,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct LearnStatus {
+    pub pairs_collected: u32,
+    pub training_queue: u32,
+    pub last_trained: Option<String>,
+    pub adapters_created: u32,
+}
+
+impl LearningEngine {
+    pub fn new(sidecar_url: &str, enabled: bool) -> Self {
+        Self {
+            sidecar_url: sidecar_url.to_string(),
+            enabled,
+            client: reqwest::Client::new(),
+        }
+    }
+
+    /// Submit a response for evaluation (async, non-blocking)
+    pub async fn evaluate(&self, request: EvalRequest) -> Result<EvalResponse> {
+        if !self.enabled {
+            return Ok(EvalResponse {
+                score: 5.0,
+                improved_response: None,
+                feedback: "Learning disabled".into(),
+            });
+        }
+
+        let resp = self.client
+            .post(format!("{}/evaluate", self.sidecar_url))
+            .json(&request)
+            .send()
+            .await?
+            .json()
+            .await?;
+
+        Ok(resp)
+    }
+
+    /// Trigger training immediately
+    pub async fn train_now(&self, request: TrainRequest) -> Result<TrainResponse> {
+        let resp = self.client
+            .post(format!("{}/train", self.sidecar_url))
+            .json(&request)
+            .send()
+            .await?
+            .json()
+            .await?;
+
+        Ok(resp)
+    }
+
+    /// Get learning status
+    pub async fn status(&self) -> Result<LearnStatus> {
+        if !self.enabled {
+            return Ok(LearnStatus {
+                pairs_collected: 0,
+                training_queue: 0,
+                last_trained: None,
+                adapters_created: 0,
+            });
+        }
+
+        let resp = self.client
+            .get(format!("{}/status", self.sidecar_url))
+            .send()
+            .await?
+            .json()
+            .await?;
+
+        Ok(resp)
+    }
+}

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

@@ -0,0 +1,5 @@
+pub mod engine;
+pub mod cloud_fallback;
+
+pub use engine::LearningEngine;
+pub use cloud_fallback::CloudFallback;

package/crates/synapse/src/main.rs

@@ -0,0 +1,185 @@
+mod cli;
+mod config;
+mod dashboard;
+mod inference;
+mod server;
+mod openai;
+mod streaming;
+mod swarm;
+mod learn;
+mod memory;
+mod vram;
+mod format;
+
+use clap::{Parser, Subcommand};
+use anyhow::Result;
+
+#[derive(Parser)]
+#[command(name = "synapse")]
+#[command(about = "TITAN Synapse — Small models that think together. And learn.")]
+#[command(version)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Start the Synapse inference server
+    Serve {
+        /// Port to listen on
+        #[arg(short, long, default_value = "6900")]
+        port: u16,
+        /// Config file path
+        #[arg(short, long)]
+        config: Option<String>,
+    },
+    /// Show system status (GPU, loaded models, VRAM)
+    Status,
+    /// List available models
+    Models,
+    /// Pull a model from HuggingFace
+    Pull {
+        /// Model name (e.g., qwen3-3b, qwen3-0.6b)
+        model: String,
+    },
+    /// Export a specialist as .synapse file
+    Export {
+        /// Specialist name
+        name: String,
+        /// Output path
+        #[arg(short, long)]
+        output: Option<String>,
+    },
+    /// Import a .synapse specialist file
+    Import {
+        /// Path to .synapse file
+        path: String,
+    },
+    /// Show learning engine status
+    Learn {
+        #[command(subcommand)]
+        command: LearnCommands,
+    },
+    /// Run inference benchmarks
+    Bench {
+        /// Model to benchmark
+        #[arg(short, long)]
+        model: Option<String>,
+    },
+    /// Run standardized evaluation (MMLU, HumanEval, MT-Bench, Safety)
+    Eval,
+    /// Community Specialist Hub — share and discover trained specialists
+    Hub {
+        #[command(subcommand)]
+        command: HubCommands,
+    },
+    /// Train our own Synapse model from scratch (SFT + DPO + GGUF export)
+    Train {
+        /// Training stage: full, sft, dpo, export
+        #[arg(short, long, default_value = "full")]
+        stage: String,
+        /// Base model architecture (Apache 2.0 licensed, we fine-tune into OUR model)
+        #[arg(short, long, default_value = "Qwen/Qwen2.5-3B")]
+        base_model: String,
+        /// Output model name
+        #[arg(short, long, default_value = "synapse-3b")]
+        output: String,
+    },
+    /// Start the server (alias for serve)
+    Up {
+        /// Port to listen on
+        #[arg(short, long, default_value = "6900")]
+        port: u16,
+    },
+}
+
+#[derive(Subcommand)]
+enum LearnCommands {
+    /// Show learning status
+    Status,
+    /// Force training now
+    TrainNow,
+}
+
+#[derive(Subcommand)]
+enum HubCommands {
+    /// Search for community specialists
+    Search {
+        /// Search query
+        query: String,
+    },
+    /// Install a specialist from HuggingFace
+    Install {
+        /// HuggingFace repo (e.g., user/synapse-python-expert)
+        repo: String,
+    },
+    /// Push your trained specialist to HuggingFace
+    Push {
+        /// Specialist name to push
+        name: String,
+    },
+    /// List hub info and commands
+    List,
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "synapse=info".into()),
+        )
+        .init();
+
+    let cli = Cli::parse();
+    let cfg = config::SynapseConfig::load(None)?;
+
+    match cli.command {
+        Commands::Serve { port, config: config_path } => {
+            let cfg = if let Some(path) = config_path {
+                config::SynapseConfig::load(Some(&path))?
+            } else {
+                cfg
+            };
+            server::run(cfg, port).await
+        }
+        Commands::Up { port } => {
+            server::run(cfg, port).await
+        }
+        Commands::Status => {
+            cli::status::run(&cfg).await
+        }
+        Commands::Models => {
+            cli::models::run(&cfg).await
+        }
+        Commands::Pull { model } => {
+            cli::pull::run(&cfg, &model).await
+        }
+        Commands::Export { name, output } => {
+            cli::export::run(&cfg, &name, output.as_deref()).await
+        }
+        Commands::Import { path } => {
+            cli::import::run(&cfg, &path).await
+        }
+        Commands::Learn { command } => match command {
+            LearnCommands::Status => cli::learn::status(&cfg).await,
+            LearnCommands::TrainNow => cli::learn::train_now(&cfg).await,
+        },
+        Commands::Bench { model } => {
+            cli::bench::run(&cfg, model.as_deref()).await
+        }
+        Commands::Eval => {
+            cli::eval::run(&cfg).await
+        }
+        Commands::Train { stage, base_model, output } => {
+            cli::train::run(&cfg, &stage, &base_model, &output).await
+        }
+        Commands::Hub { command } => match command {
+            HubCommands::Search { query } => cli::hub::search(&query).await,
+            HubCommands::Install { repo } => cli::hub::install(&cfg, &repo).await,
+            HubCommands::Push { name } => cli::hub::push(&cfg, &name).await,
+            HubCommands::List => cli::hub::list().await,
+        }
+    }
+}

package/crates/synapse/src/memory/extractor.rs

@@ -0,0 +1,201 @@
+use anyhow::Result;
+use super::graph::KnowledgeGraph;
+
+/// Extracts structured knowledge from conversations in real-time.
+/// This is what makes "learns from every conversation" real — not just logging,
+/// but actually building a queryable knowledge graph from natural language.
+pub struct KnowledgeExtractor;
+
+impl KnowledgeExtractor {
+    /// Extract facts from a conversation message and store in the knowledge graph.
+    /// Uses pattern matching for common fact patterns:
+    /// - "X is Y" → (X, is_a, Y)
+    /// - "X was created by Y" → (X, created_by, Y)
+    /// - "X uses Y" → (X, uses, Y)
+    /// - "X runs on Y" → (X, runs_on, Y)
+    /// - "X supports Y" → (X, supports, Y)
+    pub fn extract_and_store(kg: &KnowledgeGraph, text: &str, source: &str) -> Result<u32> {
+        let mut facts_added = 0;
+        let sentences: Vec<&str> = text.split(['.', '!', '\n'])
+            .map(|s| s.trim())
+            .filter(|s| s.len() > 5 && s.len() < 500)
+            .collect();
+
+        for sentence in &sentences {
+            let lower = sentence.to_lowercase();
+
+            // Pattern: "X is a/an Y"
+            if let Some(fact) = extract_is_pattern(&lower, sentence) {
+                kg.add_fact(&fact.0, &fact.1, &fact.2, Some(source))?;
+                facts_added += 1;
+            }
+
+            // Pattern: "X uses/runs/supports Y"
+            for (keyword, predicate) in &[
+                ("uses", "uses"),
+                ("runs on", "runs_on"),
+                ("supports", "supports"),
+                ("requires", "requires"),
+                ("depends on", "depends_on"),
+                ("created by", "created_by"),
+                ("built with", "built_with"),
+                ("written in", "written_in"),
+            ] {
+                if let Some(fact) = extract_verb_pattern(&lower, sentence, keyword, predicate) {
+                    kg.add_fact(&fact.0, &fact.1, &fact.2, Some(source))?;
+                    facts_added += 1;
+                }
+            }
+        }
+
+        if facts_added > 0 {
+            tracing::debug!("Extracted {facts_added} facts from conversation");
+        }
+
+        Ok(facts_added)
+    }
+
+    /// Extract user preferences from conversation patterns
+    pub fn extract_preferences(kg: &KnowledgeGraph, user_msg: &str, assistant_msg: &str, specialist: &str) -> Result<()> {
+        // If user says "good", "thanks", "correct", "exactly" — positive signal
+        let positive_signals = ["good", "thanks", "correct", "exactly", "perfect", "great", "nice"];
+        let negative_signals = ["wrong", "incorrect", "no,", "that's not", "actually,", "nope"];
+
+        let user_lower = user_msg.to_lowercase();
+
+        let is_positive = positive_signals.iter().any(|s| user_lower.contains(s));
+        let is_negative = negative_signals.iter().any(|s| user_lower.contains(s));
+
+        if is_positive && !is_negative {
+            // This was a good response — could be used as chosen in DPO
+            tracing::debug!("Positive feedback detected for {specialist}");
+        } else if is_negative && !is_positive {
+            // This was a bad response — store for improvement
+            // Store as a preference pair with placeholder improved response
+            kg.add_preference(specialist, user_msg, "(needs improvement)", assistant_msg)?;
+            tracing::debug!("Negative feedback detected for {specialist} — stored preference pair");
+        }
+
+        Ok(())
+    }
+}
+
+/// Extract "X is a/an Y" patterns
+fn extract_is_pattern(lower: &str, _original: &str) -> Option<(String, String, String)> {
+    // Look for "X is a Y" or "X is an Y"
+    let patterns = [" is a ", " is an ", " is the "];
+    for pattern in patterns {
+        if let Some(pos) = lower.find(pattern) {
+            let subject = lower[..pos].trim();
+            let object = lower[pos + pattern.len()..].trim();
+
+            // Only extract if both parts are reasonable length
+            if subject.len() > 1 && subject.len() < 100 && object.len() > 1 && object.len() < 200 {
+                // Clean up subject (take last noun phrase)
+                let subject = subject.split_whitespace().collect::<Vec<_>>();
+                let subject = if subject.len() > 3 {
+                    subject[subject.len()-3..].join(" ")
+                } else {
+                    subject.join(" ")
+                };
+
+                return Some((
+                    capitalize(&subject),
+                    "is_a".to_string(),
+                    object.to_string(),
+                ));
+            }
+        }
+    }
+    None
+}
+
+/// Extract "X verb Y" patterns
+fn extract_verb_pattern(lower: &str, _original: &str, keyword: &str, predicate: &str) -> Option<(String, String, String)> {
+    if let Some(pos) = lower.find(keyword) {
+        let subject = lower[..pos].trim();
+        let object = lower[pos + keyword.len()..].trim();
+
+        if subject.len() > 1 && subject.len() < 100 && object.len() > 1 && object.len() < 200 {
+            let subject = subject.split_whitespace().collect::<Vec<_>>();
+            let subject = if subject.len() > 3 {
+                subject[subject.len()-3..].join(" ")
+            } else {
+                subject.join(" ")
+            };
+
+            return Some((
+                capitalize(&subject),
+                predicate.to_string(),
+                object.to_string(),
+            ));
+        }
+    }
+    None
+}
+
+fn capitalize(s: &str) -> String {
+    let mut chars = s.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(c) => c.to_uppercase().collect::<String>() + chars.as_str(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+    use std::path::Path;
+
+    fn test_kg() -> KnowledgeGraph {
+        let tmp = tempdir().unwrap();
+        KnowledgeGraph::new(&tmp.path().join("test.db")).unwrap()
+    }
+
+    #[test]
+    fn test_extract_is_pattern() {
+        let kg = test_kg();
+        let text = "Python is a programming language. It was designed by Guido van Rossum.";
+        let count = KnowledgeExtractor::extract_and_store(&kg, text, "test").unwrap();
+        assert!(count >= 1, "Should extract at least 1 fact, got {count}");
+
+        let facts = kg.query_facts("Python").unwrap();
+        assert!(!facts.is_empty(), "Should have facts about Python");
+    }
+
+    #[test]
+    fn test_extract_verb_patterns() {
+        let kg = test_kg();
+        let text = "TITAN Synapse uses Rust for the inference engine. The project runs on CUDA GPUs.";
+        let count = KnowledgeExtractor::extract_and_store(&kg, text, "test").unwrap();
+        assert!(count >= 1, "Should extract at least 1 fact, got {count}");
+    }
+
+    #[test]
+    fn test_extract_preferences_positive() {
+        let kg = test_kg();
+        KnowledgeExtractor::extract_preferences(
+            &kg, "Thanks, that's correct!", "Python is dynamically typed.", "python_expert"
+        ).unwrap();
+        // Positive feedback shouldn't create a preference pair
+        assert_eq!(kg.preference_count("python_expert").unwrap(), 0);
+    }
+
+    #[test]
+    fn test_extract_preferences_negative() {
+        let kg = test_kg();
+        KnowledgeExtractor::extract_preferences(
+            &kg, "No, that's not right at all", "Python is statically typed.", "python_expert"
+        ).unwrap();
+        // Negative feedback should create a preference pair
+        assert_eq!(kg.preference_count("python_expert").unwrap(), 1);
+    }
+
+    #[test]
+    fn test_empty_text() {
+        let kg = test_kg();
+        let count = KnowledgeExtractor::extract_and_store(&kg, "", "test").unwrap();
+        assert_eq!(count, 0);
+    }
+}