refactor: Remove proxy dependency, use direct MedGemma client

- Created DirectMedGemmaClient that connects directly to HF API or local models
- Removed ProxyClient dependency on terraphim-llm-proxy service
- Auto-detection: HF API → Local ctransformers → Mock fallback
- Updated demo.rs to use direct client instead of proxy
- Added shellexpand dependency for path expansion
- Simplifies deployment - no external proxy service required
- Works with HF_TOKEN env var or local model files

Author: kimiko-terraphim

crates/terraphim-demo/Cargo.toml

@@ -23,3 +23,4 @@ anyhow = { workspace = true }
 reqwest = { workspace = true }
 tracing = { workspace = true }
 async-trait = { workspace = true }
+shellexpand = "3.0"

crates/terraphim-demo/src/demo.rs

@@ -11,10 +11,9 @@
 use crate::consultation::{
     ClinicalEntities, ConsultationWorkflow, PGxValidation, SafetyCheck, TreatmentRecommendation,
 };
+use crate::direct_client::DirectMedGemmaClient;
 use crate::patients::{get_demo_patient, PatientProfile};
-use crate::proxy_client::ProxyClient;
 use medgemma_client::client::MedGemmaClient;
-use medgemma_client::mock::MockMedGemmaClient;
 use std::io;
 use std::sync::Arc;
 use terraphim_automata::EntityExtractor;
@@ -72,29 +71,32 @@ pub async fn run_demo() {
     let _ = io::stdin().read_line(&mut String::new());
 }
 
-/// Initialize MedGemma client with proxy as primary, fallback to mock
+/// Initialize MedGemma client with direct connection (no proxy required)
 async fn init_medgemma_client() -> Arc<dyn MedGemmaClient + Send + Sync> {
-    // Try to create proxy client
-    let proxy_client = ProxyClient::new();
-
-    // Check if proxy is available
-    if proxy_client.is_available().await {
-        let backend_info = proxy_client.backend_info();
-        println!(
-            "[OK] Using terraphim-llm-proxy at {} (source: {})",
-            backend_info.name,
-            std::env::var("PROXY_URL").as_deref().unwrap_or("default")
-        );
-        return Arc::new(proxy_client);
+    let client = DirectMedGemmaClient::new().await;
+    let backend_info = client.backend_info();
+    
+    match backend_info.health {
+        medgemma_client::BackendHealth::Healthy => {
+            println!(
+                "[OK] MedGemma client ready: {} (healthy)",
+                backend_info.name
+            );
+        }
+        medgemma_client::BackendHealth::Degraded => {
+            println!(
+                "[WARN] MedGemma client degraded: {} (falling back to mock)",
+                backend_info.name
+            );
+        }
+        medgemma_client::BackendHealth::Unhealthy => {
+            println!(
+                "[INFO] Using mock MedGemma client (set HF_TOKEN for real inference)"
+            );
+        }
     }
-
-    // Fallback to mock client if proxy is not available
-    println!("[WARN] terraphim-llm-proxy not available, falling back to mock client");
-    println!(
-        "       (Proxy should be running at {})",
-        proxy_client.backend_info().name
-    );
-    Arc::new(MockMedGemmaClient::new())
+    
+    Arc::new(client)
 }
 
 fn print_header() {

crates/terraphim-demo/src/direct_client.rs

@@ -0,0 +1,157 @@
+//! Simplified MedGemma client - Direct connection without proxy
+//!
+//! This client connects directly to HuggingFace or local MedGemma models
+//! without requiring the terraphim-llm-proxy service.
+
+use async_trait::async_trait;
+use medgemma_client::{
+    client::MedGemmaClient, BackendHealth, BackendInfo, ClientError, Explanation, PatientProfile,
+    Recommendation, Result,
+};
+use std::time::Duration;
+
+/// Direct MedGemma client using HF API or local inference
+pub struct DirectMedGemmaClient {
+    inner: Box<dyn MedGemmaClient + Send + Sync>,
+    backend_info: BackendInfo,
+}
+
+impl DirectMedGemmaClient {
+    /// Create a new direct client with auto-detection
+    ///
+    /// Tries in order:
+    /// 1. HuggingFace API (if HF_TOKEN env var set)
+    /// 2. Local ctransformers (if model file exists)
+    /// 3. Mock client (fallback)
+    pub async fn new() -> Self {
+        // Try HuggingFace API first
+        if let Ok(token) = std::env::var("HF_TOKEN") {
+            match Self::try_hf_api(&token).await {
+                Ok(client) => {
+                    return client;
+                }
+                Err(e) => {
+                    eprintln!("[WARN] HF API failed: {}, trying local...", e);
+                }
+            }
+        }
+
+        // Try local ctransformers
+        match Self::try_local().await {
+            Ok(client) => client,
+            Err(e) => {
+                eprintln!("[WARN] Local inference failed: {}, using mock", e);
+                Self::mock()
+            }
+        }
+    }
+
+    /// Create a mock client for testing
+    pub fn mock() -> Self {
+        use medgemma_client::mock::MockMedGemmaClient;
+        
+        let mock = MockMedGemmaClient::new();
+        let backend_info = mock.backend_info();
+        
+        Self {
+            inner: Box::new(mock),
+            backend_info,
+        }
+    }
+
+    /// Try to use HuggingFace API
+    async fn try_hf_api(token: &str) -> Result<Self> {
+        use medgemma_client::hf::HfMedGemmaClient;
+        
+        let client = HfMedGemmaClient::new(token.to_string())
+            .map_err(|e| ClientError::Init(e.to_string()))?;
+        
+        let backend_info = client.backend_info();
+        
+        Ok(Self {
+            inner: Box::new(client),
+            backend_info,
+        })
+    }
+
+    /// Try to use local ctransformers
+    async fn try_local() -> Result<Self> {
+        use medgemma_client::local::LocalMedGemmaClient;
+        
+        // Check for common model paths
+        let model_paths = [
+            "./models/medgemma-4b-it-q4_k_m.gguf",
+            "./medgemma-4b-it-q4_k_m.gguf",
+            "~/models/medgemma-4b-it-q4_k_m.gguf",
+        ];
+        
+        for path in &model_paths {
+            let expanded = shellexpand::tilde(path);
+            if std::path::Path::new(expanded.as_ref()).exists() {
+                let client = LocalMedGemmaClient::new(expanded.to_string())
+                    .map_err(|e| ClientError::Init(e.to_string()))?;
+                
+                let backend_info = client.backend_info();
+                
+                return Ok(Self {
+                    inner: Box::new(client),
+                    backend_info,
+                });
+            }
+        }
+        
+        Err(ClientError::Init("No local model found".to_string()))
+    }
+
+    /// Get backend information
+    pub fn backend_info(&self) -> &BackendInfo {
+        &self.backend_info
+    }
+
+    /// Check if using real inference (not mock)
+    pub fn is_real(&self) -> bool {
+        !matches!(self.backend_info.health, BackendHealth::Unhealthy)
+    }
+}
+
+#[async_trait]
+impl MedGemmaClient for DirectMedGemmaClient {
+    async fn recommend_treatment(
+        &self,
+        patient: &PatientProfile,
+    ) -> Result<Recommendation> {
+        self.inner.recommend_treatment(patient).await
+    }
+
+    async fn explain_recommendation(
+        &self,
+        patient: &PatientProfile,
+        recommendation: &Recommendation,
+    ) -> Result<Explanation> {
+        self.inner.explain_recommendation(patient, recommendation).await
+    }
+
+    async fn validate_safety(
+        &self,
+        patient: &PatientProfile,
+        recommendation: &Recommendation,
+    ) -> Result<bool> {
+        self.inner.validate_safety(patient, recommendation).await
+    }
+
+    fn backend_info(&self) -> BackendInfo {
+        self.backend_info.clone()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_mock_client() {
+        let client = DirectMedGemmaClient::mock();
+        assert!(!client.is_real());
+        assert_eq!(client.backend_info().name, "MockMedGemma");
+    }
+}

crates/terraphim-demo/src/lib.rs

@@ -10,12 +10,13 @@
 
 pub mod consultation;
 pub mod demo;
+pub mod direct_client;
 pub mod patients;
-pub mod proxy_client;
 
 pub use consultation::{
     ClinicalEntities, ConsultationResult, ConsultationStep, ConsultationWorkflow, PGxValidation,
     SafetyCheck, StepResult, TreatmentRecommendation, WorkflowStatus,
 };
 pub use demo::run_demo;
+pub use direct_client::DirectMedGemmaClient;
 pub use patients::{get_afib_patient, get_demo_patient, PatientProfile};