Fix: Replace NeMo/OpenAI with Dolphin Agent (HF Inference)

app.py

@@ -391,25 +391,26 @@ with gr.Blocks(theme=gr.themes.Monochrome(), title="LOGOS SPCW Protocol") as dem
                 history = history or []
                 history.append((message, None))
                 
-                # Try NeMo connector first, fallback to simple response
+                # Try Dolphin connector first, fallback to simple response
                 try:
                     from logos.connectors import get_connector
-                    nemo = get_connector('nemo')
+                    dolphin = get_connector('dolphin')
                     
-                    # Add LOGOS context to prompt
-                    logos_context = f"""You are LOGOS, an AI assistant specialized in:
+                    # LOGOS System Context
+                    logos_context = """You are LOGOS, an AI assistant specialized in:
 - Prime Network Architecture (integer topology, GCD routing)
 - SPCW (Structured Prime Composite Waveform) protocol
 - Hex/Binary Dissolution and enterprise routing
 - Fractal addressing and heat code encoding
-
-User query: {message}"""
+"""
                     
-                    response = nemo.chat(logos_context)
+                    # Use Dolphin Chat
+                    # My DolphinAgentConnector.chat takes (message, system_prompt)
+                    response = dolphin.chat(message, system_prompt=logos_context)
                     history[-1] = (message, response)
                 except Exception as e:
                     # Fallback response
-                    history[-1] = (message, f"*[AI unavailable: {str(e)}]*\n\nTo enable AI:\n1. Get API key from [build.nvidia.com](https://build.nvidia.com)\n2. Set `NVIDIA_API_KEY` environment variable\n3. Install: `pip install nvidia-nat openai`")
+                    history[-1] = (message, f"*[AI unavailable: {str(e)}]*\n\nTo enable AI:\n1. Ensure `HF_TOKEN` is set in Space secrets.\n2. Ensure `huggingface_hub` is installed.")
                 
                 return history, ""
             
@@ -426,7 +427,7 @@ User query: {message}"""
                     ('hf', 'Hugging Face'),
                     ('ocr', 'EasyOCR'),
                     ('vision', 'Vision (CV)'),
-                    ('nemo', 'NeMo Agent'),
+                    ('dolphin', 'Dolphin AI'),
                     ('browser', 'Browser Automation')
                 ]
                 

logos/connectors.py

@@ -219,82 +219,68 @@ class VisionConnector:
             raise ImportError(f"Required library not installed: {e}")
 
 # ==========================================
-# NEMO AGENT CONNECTOR (NVIDIA)
+# DOLPHIN AGENT CONNECTOR (HF Inference)
 # ==========================================
 
-class NeMoAgentConnector:
+class DolphinAgentConnector:
     """
-    Adapter for NVIDIA NeMo Agent Toolkit.
-    Provides ReAct agents, tool calling, and vision-language models.
+    Adapter for Dolphin AI (via Hugging Face Inference).
+    Replaces NeMo/OpenAI dependency with open weights.
     """
     
-    def __init__(self, api_key: Optional[str] = None, base_url: str = "https://integrate.api.nvidia.com/v1"):
-        self.api_key = api_key or os.environ.get('NVIDIA_API_KEY')
-        self.base_url = base_url
-        self._agent = None
+    def __init__(self, model: str = "cognitivecomputations/dolphin-2.9-llama3-8b"):
+        self.model = model
+        self.config = ConnectorConfig.from_env()
+        self._client = None
     
-    def _ensure_agent(self):
-        """Lazy initialization of NeMo Agent."""
-        if self._agent is None:
+    def _ensure_client(self):
+        """Lazy initialization of HF Inference Client."""
+        if self._client is None:
             try:
-                from nat import Agent
-                self._agent = Agent(api_key=self.api_key, base_url=self.base_url)
+                from huggingface_hub import InferenceClient
+                self._client = InferenceClient(token=self.config.hf_token)
             except ImportError:
-                raise ImportError("nvidia-nat not installed. Run: pip install nvidia-nat")
-        return self._agent
+                raise ImportError("huggingface_hub not installed.")
+        return self._client
     
-    def chat(self, message: str, model: str = "nvidia/nemotron-3-nano-30b-a3b") -> str:
+    def chat(self, message: str, system_prompt: str = None) -> str:
         """
-        Chat with NeMo agent.
-        
-        Args:
-            message: User message
-            model: NVIDIA model ID
-            
-        Returns:
-            Agent response
+        Chat with Dolphin agent.
         """
         try:
-            from openai import OpenAI
-            client = OpenAI(api_key=self.api_key, base_url=self.base_url)
-            response = client.chat.completions.create(
-                model=model,
-                messages=[{"role": "user", "content": message}]
-            )
-            return response.choices[0].message.content
+            client = self._ensure_client()
+            
+            messages = []
+            if system_prompt:
+                messages.append({"role": "system", "content": system_prompt})
+            messages.append({"role": "user", "content": message})
+            
+            # Using basic text generation if chat template fails, but try chat first
+            # Many HF models support chat_completion API via InferenceClient
+            try:
+                response = client.chat_completion(
+                    messages=messages,
+                    model=self.model,
+                    max_tokens=500
+                )
+                return response.choices[0].message.content
+            except Exception:
+                # Fallback to text generation
+                prompt = f"<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
+                return client.text_generation(prompt, model=self.model, max_new_tokens=500)
+                
         except Exception as e:
-            return f"[NeMo Error] {e}"
+            return f"[Dolphin Error] {e}"
     
-    def analyze_diagram(self, image_path: str, prompt: str = "Describe this architectural diagram in detail.") -> str:
+    def analyze_diagram(self, image_path: str, prompt: str = "Describe this architectural diagram.") -> str:
         """
-        Analyze diagram/image using vision-language model.
-        
-        Args:
-            image_path: Path to image
-            prompt: Analysis prompt
-            
-        Returns:
-            Analysis text
+        Analyze diagram using visual model (fallback to simple captioning if Dolphin is text-only).
         """
         try:
-            import base64
-            from openai import OpenAI
-            
-            with open(image_path, 'rb') as f:
-                image_data = base64.b64encode(f.read()).decode('utf-8')
-            
-            client = OpenAI(api_key=self.api_key, base_url=self.base_url)
-            response = client.chat.completions.create(
-                model="nvidia/nemotron-nano-12b-v2-vl",
-                messages=[{
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": prompt},
-                        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}}
-                    ]
-                }]
-            )
-            return response.choices[0].message.content
+            # Dolphin is text-only usually. Route to a Vision model.
+            from .connectors import get_connector # lazy import
+            hf = get_connector('hf')
+            return hf.image_to_text(image_path)
         except Exception as e:
             return f"[Vision Error] {e}"
 
@@ -442,7 +428,7 @@ def get_connector(connector_type: str, **kwargs) -> Any:
         'hf': HuggingFaceConnector,
         'ocr': OCRConnector,
         'vision': VisionConnector,
-        'nemo': NeMoAgentConnector,
+        'dolphin': DolphinAgentConnector,
         'browser': BrowserAutomationConnector
     }
     
@@ -475,11 +461,11 @@ AVAILABLE_CONNECTORS = {
         'requires': ['opencv-python-headless', 'scikit-image'],
         'env_vars': []
     },
-    'nemo': {
-        'name': 'NVIDIA NeMo Agent Toolkit',
-        'capabilities': ['chat', 'analyze_diagram', 'react_agent', 'tool_calling'],
-        'requires': ['nvidia-nat', 'openai'],
-        'env_vars': ['NVIDIA_API_KEY']
+    'dolphin': {
+        'name': 'Dolphin AI (HF Inference)',
+        'capabilities': ['chat', 'analyze_diagram'],
+        'requires': ['huggingface_hub'],
+        'env_vars': ['HF_TOKEN']
     },
     'browser': {
         'name': 'Browser Automation (smolagents)',