refactor (model and interface): new NER models and respective interface

CONFIGURATION_GUIDE.md

@@ -13,12 +13,33 @@ The Pub/Sub Multi-Agent System now supports saving and loading complete configur
 ### How to Save
 
 1. Configure your data sources and agents
-2. Click the **"Save Config"** button in the top-right header
-3. A JSON file will download automatically with the name pattern:
+2. **(Optional)** Check "☑ Save results" to include execution results
+3. Click the **"Save Config"** button in the top-right header
+4. A JSON file will download automatically with the name pattern:
    ```
    pubsub-config-YYYY-MM-DD.json
    ```
 
+### Save Results Checkbox
+
+The **"☑ Save results"** checkbox allows you to include execution results in the saved configuration.
+
+**When checked**, the config includes:
+- All configuration data (agents, data sources)
+- Final Result box content
+- NER Result box content
+- Execution Log content
+
+**When unchecked** (default):
+- Only configuration data is saved
+- No results or logs
+
+**Use cases for saving results**:
+- Document successful executions
+- Share complete analysis with team
+- Archive results with configuration
+- Review past executions later
+
 ### What Gets Saved
 
 The configuration file includes:
@@ -32,9 +53,14 @@ The configuration file includes:
   - Model selection
   - Subscribe/Publish topics
   - Show result checkbox state
+- **Results** (if "Save results" checked):
+  - Final Result box content
+  - NER Result box content
+  - Execution Log content
 
 ### Example Configuration File
 
+**Without Results**:
 ```json
 {
   "version": "1.0",
@@ -44,16 +70,12 @@ The configuration file includes:
     {
       "label": "Schema",
       "content": "Tables:\n- customers (id, name, email)\n- orders (id, customer_id, total)"
-    },
-    {
-      "label": "Rules",
-      "content": "Always use LEFT JOIN for optional relationships"
     }
   ],
   "agents": [
     {
       "title": "SQL Generator",
-      "prompt": "Generate SQL for: {question}\nSchema: {schema}\nRules: {rules}",
+      "prompt": "Generate SQL for: {question}\nSchema: {schema}",
       "model": "phi3",
       "subscribeTopic": "START",
       "publishTopic": "SQL_GENERATED",
@@ -63,6 +85,22 @@ The configuration file includes:
 }
 ```
 
+**With Results** (when "Save results" is checked):
+```json
+{
+  "version": "1.0",
+  "timestamp": "2026-02-01T10:30:00.000Z",
+  "userQuestion": "Extract medical entities from patient note",
+  "dataSources": [...],
+  "agents": [...],
+  "results": {
+    "finalResult": "--- Entity Extractor ---\n[{\"text\": \"diabetes\", \"entity_type\": \"PROBLEM\"}]",
+    "nerResult": "Patient has [diabetes:PROBLEM] and takes [metformin:TREATMENT]",
+    "executionLog": "[10:30:00] ℹ️ Starting...\n[10:30:05] ✅ Complete"
+  }
+}
+```
+
 ## Load Configuration
 
 ### How to Load
@@ -80,8 +118,12 @@ The configuration file includes:
 
 - **Current config is replaced**: All existing data sources and agents are removed
 - **New IDs assigned**: Loaded items get new unique IDs
-- **Logs cleared**: Execution log is reset
-- **Results cleared**: Final result box is cleared
+- **Results restored** (if saved with results):
+  - Final Result box populated
+  - NER Result box populated
+  - Execution Log populated
+- **Empty boxes** (if no results saved):
+  - All result boxes cleared
 - **Validation**: File is checked for proper format before loading
 
 ### Error Handling
@@ -398,7 +440,7 @@ merge_configs("pipeline-a.json", "pipeline-b.json", "merged-pipeline.json")
 ### Issue: Agents not working after load
 
 **Cause**: Model might not be available  
-**Solution**: Check agent "model" field matches available models (phi3, MedAIBase/MedGemma1.5:4b)
+**Solution**: Check agent "model" field matches available models (phi3, cniongolo/biomistral)
 
 ### Issue: Topics not matching after load
 

Dockerfile

@@ -51,6 +51,12 @@ ollama pull MedAIBase/MedGemma1.5:4b\n\
 echo "Pulling DeepSeek Coder model..."\n\
 ollama pull deepseek-coder:1.3b\n\
 \n\
+echo "Pulling Clinical NER model..."\n\
+ollama pull samrawal/bert-base-uncased_clinical-ner\n\
+\n\
+echo "Pulling Anatomy NER model..."\n\
+ollama pull OpenMed/OpenMed-NER-AnatomyDetect-BioPatient-108M\n\
+\n\
 echo "Models ready! Starting FastAPI server..."\n\
 exec uvicorn server:app --host 0.0.0.0 --port 7860\n\
 ' > /app/start.sh && chmod +x /app/start.sh

NER_AGENTS_GUIDE.md

@@ -0,0 +1,421 @@
+# Named Entity Recognition (NER) Agents Guide
+
+## Overview
+
+The Pub/Sub Multi-Agent System now includes specialized NER (Named Entity Recognition) agents that can extract medical entities from text. These agents work differently from regular LLM agents and have dedicated output displays.
+
+## Available NER Models
+
+### 1. Clinical NER Model
+**Model**: `samrawal/bert-base-uncased_clinical-ner`
+
+**Purpose**: Extract clinical entities from medical text
+
+**Recognized Entity Types**:
+- **PROBLEM**: Diseases, conditions, symptoms
+- **TREATMENT**: Medications, procedures, therapies
+- **TEST**: Diagnostic tests, lab results
+- **OCCURRENCE**: Medical events, admissions
+
+**Best for**:
+- Clinical notes
+- Patient reports
+- Medical records
+- Symptom descriptions
+
+### 2. Anatomy Detection Model
+**Model**: `OpenMed/OpenMed-NER-AnatomyDetect-BioPatient-108M`
+
+**Purpose**: Detect anatomical structures and patient information
+
+**Recognized Entity Types**:
+- **ANATOMY**: Body parts, organs, anatomical structures
+- **PATIENT**: Patient demographics, identifiers
+- **BIOMARKER**: Biological markers
+- **CLINICAL_FINDING**: Clinical observations
+
+**Best for**:
+- Anatomical descriptions
+- Radiology reports
+- Surgical notes
+- Physical examination records
+
+## How NER Agents Work
+
+### Different from Regular Agents
+
+**Regular LLM Agents**:
+- Process prompts with placeholders
+- Generate text responses
+- Use `{input}`, `{question}`, `{DataSource}` placeholders
+
+**NER Agents**:
+- Receive text through the message bus
+- Extract named entities automatically
+- Output JSON with entity information
+- Display formatted results in NER Result box
+
+### Special Behavior
+
+1. **Automatic Processing**: No prompt template needed - just feed text via bus
+2. **Dual Output**: 
+   - JSON result (for chaining to other agents)
+   - Formatted display (for human reading)
+3. **Dedicated Display**: NER Result box shows entities inline with text
+
+## Using NER Agents
+
+### Basic Setup
+
+**Agent Configuration**:
+```
+Title: Clinical Entity Extractor
+Model: samrawal/bert-base-uncased_clinical-ner
+Subscribe Topic: TEXT_TO_ANALYZE
+Publish Topic: ENTITIES_FOUND
+☑ Show result in Final Result box
+```
+
+**What happens**:
+1. Agent receives text from `TEXT_TO_ANALYZE` topic
+2. Extracts entities automatically
+3. Publishes JSON to `ENTITIES_FOUND` topic
+4. Shows JSON in Final Result box
+5. Shows formatted text in NER Result box
+
+### Output Format
+
+**JSON Output** (in Final Result box):
+```json
+[
+  {
+    "text": "diabetes",
+    "entity_type": "PROBLEM",
+    "start": 45,
+    "end": 53
+  },
+  {
+    "text": "metformin",
+    "entity_type": "TREATMENT",
+    "start": 78,
+    "end": 87
+  }
+]
+```
+
+**Formatted Output** (in NER Result box):
+```
+Patient reports history of [diabetes:PROBLEM] and is taking [metformin:TREATMENT].
+```
+
+## Example Workflows
+
+### Example 1: Clinical Note Analysis
+
+**Data Source**:
+- Label: `ClinicalNote`
+- Content:
+```
+Patient presents with chest pain and shortness of breath.
+History of hypertension and diabetes mellitus type 2.
+Currently taking lisinopril 10mg daily and metformin 500mg twice daily.
+ECG shows ST elevation. Troponin levels elevated at 0.5 ng/mL.
+```
+
+**Agents**:
+
+**Agent 1: Clinical NER**
+- Title: `Extract Clinical Entities`
+- Model: `samrawal/bert-base-uncased_clinical-ner`
+- Subscribe: `START`
+- Publish: `CLINICAL_ENTITIES`
+- Prompt: `{ClinicalNote}` *(text to analyze)*
+- ☑ Show result
+
+**Agent 2: Entity Summarizer**
+- Title: `Summarize Findings`
+- Model: `phi3`
+- Subscribe: `CLINICAL_ENTITIES`
+- Publish: *(empty)*
+- Prompt:
+```
+Based on these extracted entities:
+{input}
+
+Summarize the key clinical findings:
+1. Problems identified
+2. Treatments mentioned
+3. Tests performed
+```
+- ☑ Show result
+
+**Expected Results**:
+
+*NER Result box*:
+```
+Patient presents with [chest pain:PROBLEM] and [shortness of breath:PROBLEM].
+History of [hypertension:PROBLEM] and [diabetes mellitus type 2:PROBLEM].
+Currently taking [lisinopril:TREATMENT] 10mg daily and [metformin:TREATMENT] 500mg twice daily.
+[ECG:TEST] shows ST elevation. [Troponin:TEST] levels elevated at 0.5 ng/mL.
+```
+
+*Final Result box*:
+```
+--- Extract Clinical Entities ---
+[{"text": "chest pain", "entity_type": "PROBLEM", ...}, ...]
+
+--- Summarize Findings ---
+Key Clinical Findings:
+1. Problems: chest pain, shortness of breath, hypertension, diabetes
+2. Treatments: lisinopril, metformin
+3. Tests: ECG, Troponin
+```
+
+### Example 2: Anatomy Detection in Radiology Report
+
+**User Question**: "Analyze this radiology report"
+
+**Data Source**:
+- Label: `RadiologyReport`
+- Content:
+```
+CT scan of the chest reveals mass in right upper lobe measuring 3.2 cm.
+No evidence of mediastinal lymphadenopathy.
+Heart size is normal. Lungs are clear bilaterally.
+Liver and spleen appear unremarkable.
+```
+
+**Agent Configuration**:
+
+**Agent 1: Anatomy Detector**
+- Title: `Detect Anatomical Structures`
+- Model: `OpenMed/OpenMed-NER-AnatomyDetect-BioPatient-108M`
+- Subscribe: `START`
+- Publish: `ANATOMY_FOUND`
+- Prompt: `{RadiologyReport}`
+- ☑ Show result
+
+**Expected NER Result**:
+```
+CT scan of the [chest:ANATOMY] reveals mass in [right upper lobe:ANATOMY] measuring 3.2 cm.
+No evidence of [mediastinal:ANATOMY] lymphadenopathy.
+[Heart:ANATOMY] size is normal. [Lungs:ANATOMY] are clear bilaterally.
+[Liver:ANATOMY] and [spleen:ANATOMY] appear unremarkable.
+```
+
+### Example 3: Multi-Stage Medical Analysis
+
+**Workflow**: Extract entities → Categorize → Generate report
+
+**Agent 1: Entity Extraction**
+- Model: `samrawal/bert-base-uncased_clinical-ner`
+- Subscribe: `START`
+- Publish: `ENTITIES`
+- ☑ Show result
+
+**Agent 2: Entity Categorization**
+- Model: `phi3`
+- Subscribe: `ENTITIES`
+- Publish: `CATEGORIZED`
+- Prompt:
+```
+Categorize these medical entities by type:
+{input}
+
+Group by: Problems, Treatments, Tests
+```
+- ☑ Show result
+
+**Agent 3: Report Generator**
+- Model: `MedAIBase/MedGemma1.5:4b`
+- Subscribe: `CATEGORIZED`
+- Publish: *(empty)*
+- Prompt:
+```
+Generate a structured clinical summary based on:
+{input}
+
+Include assessment and plan.
+```
+- ☑ Show result
+
+## NER Result Display Features
+
+### Inline Entity Markup
+
+Entities are displayed inline with brackets and labels:
+```
+[entity text:ENTITY_TYPE]
+```
+
+### Color Coding (Future Enhancement)
+
+Different entity types could be color-coded:
+- Problems: Red
+- Treatments: Blue
+- Tests: Green
+- Anatomy: Purple
+
+### Entity Statistics (Future Enhancement)
+
+Could show count of each entity type found.
+
+## Best Practices
+
+### 1. Choosing the Right NER Model
+
+**Use Clinical NER for**:
+- General clinical text
+- Patient complaints
+- Medical history
+- Treatment plans
+
+**Use Anatomy NER for**:
+- Radiology reports
+- Surgical notes
+- Physical examination
+- Anatomical descriptions
+
+### 2. Combining NER with Other Agents
+
+**Pattern**: Extract → Analyze → Report
+```
+NER Agent → Regular LLM → Medical LLM
+```
+
+**Example**:
+1. NER extracts entities
+2. phi3 categorizes and structures
+3. MedGemma generates clinical assessment
+
+### 3. Data Source Configuration
+
+**Option A: Use Data Source**
+```
+Data Source Label: PatientNote
+Content: [clinical text]
+
+NER Agent Prompt: {PatientNote}
+```
+
+**Option B: Use Message Bus**
+```
+Previous Agent publishes clinical text
+NER Agent receives via subscription
+```
+
+### 4. Output Handling
+
+**For Human Review**:
+- ☑ Check "Show result"
+- Review in NER Result box
+
+**For Further Processing**:
+- Set Publish Topic
+- Chain to analysis agents
+- Use JSON output
+
+## Limitations
+
+### Current Limitations
+
+1. **No Prompt Templates**: NER agents don't support custom prompts
+2. **Fixed Entity Types**: Each model has predefined entity types
+3. **English Only**: Models trained on English medical text
+4. **Context Window**: Limited input text size
+
+### Workarounds
+
+**For Long Texts**:
+- Split into chunks
+- Process separately
+- Combine results
+
+**For Custom Entities**:
+- Use regular LLM with custom prompt
+- Post-process NER output with another agent
+
+## Troubleshooting
+
+### Issue: No entities detected
+
+**Causes**:
+- Text doesn't contain medical terms
+- Wrong NER model for the content type
+- Text too short or too long
+
+**Solutions**:
+- Verify text contains medical content
+- Try different NER model
+- Check text length
+
+### Issue: Entities in wrong category
+
+**Cause**: Model misclassification
+
+**Solution**: Use post-processing agent to reclassify
+
+### Issue: NER Result box empty
+
+**Causes**:
+- "Show result" not checked
+- Agent failed to execute
+- No entities found
+
+**Solutions**:
+- Check "Show result" checkbox
+- Review Execution Log for errors
+- Verify input text
+
+## Advanced Usage
+
+### Combining Multiple NER Models
+
+Run both NER models on same text:
+
+**Agent 1: Clinical NER**
+```
+Subscribe: START
+Publish: CLINICAL_ENTITIES
+```
+
+**Agent 2: Anatomy NER**
+```
+Subscribe: START
+Publish: ANATOMY_ENTITIES
+```
+
+**Agent 3: Merge Results**
+```
+Subscribe: CLINICAL_ENTITIES, ANATOMY_ENTITIES
+Combine both outputs
+```
+
+### Entity Validation
+
+Add validation agent after NER:
+
+**Agent 1: NER Extraction**
+```
+Model: Clinical NER
+Publish: RAW_ENTITIES
+```
+
+**Agent 2: Entity Validator**
+```
+Model: MedGemma
+Subscribe: RAW_ENTITIES
+Validate medical accuracy
+Publish: VALIDATED_ENTITIES
+```
+
+## Future Enhancements
+
+Planned features:
+- [ ] Color-coded entity display
+- [ ] Entity statistics dashboard
+- [ ] Confidence scores
+- [ ] Custom entity types
+- [ ] Multi-language support
+- [ ] Entity linking (to medical ontologies)
+- [ ] Batch processing

README.md

@@ -25,10 +25,12 @@ This system allows you to create and orchestrate multiple AI agents that communi
 
 - 🔄 **Dynamic Agent Creation**: Add/remove agents on the fly
 - 📡 **Pub/Sub Architecture**: Event-driven agent orchestration
-- 🤖 **Multiple Models**: Support for phi3, llama3.2, gemma2, mistral, and biomistral
+- 🤖 **Multiple Models**: Support for general, medical, coding, and NER models
 - 🎯 **Topic-Based Routing**: Agents communicate through named topics
 - 📋 **Real-Time Logging**: Watch the message flow through the bus
 - ⚙️ **Customizable Prompts**: Each agent has its own prompt template
+- 🏷️ **Named Entity Recognition**: Dedicated NER agents with formatted output display
+- 💾 **Save/Load with Results**: Save configurations including execution results and logs
 
 ## How It Works
 
@@ -92,13 +94,15 @@ Final result displayed to user
 
 ## Supported Models
 
-This deployment includes three specialized models:
+This deployment includes five specialized models:
 
 - **phi3**: General-purpose model (3.8B parameters) - Great for text analysis, SQL generation, summarization, reasoning, and general tasks
 - **MedAIBase/MedGemma1.5:4b**: Medical/healthcare model (4B parameters) - Specialized for clinical reasoning, medical documentation, and healthcare-related tasks
 - **deepseek-coder:1.3b**: Code generation model (1.3B parameters) - Optimized for programming, code analysis, debugging, and technical documentation
+- **samrawal/bert-base-uncased_clinical-ner**: Clinical NER model - Extracts medical entities (diseases, symptoms, medications) from clinical text
+- **OpenMed/OpenMed-NER-AnatomyDetect-BioPatient-108M**: Anatomy NER model (108M parameters) - Detects anatomical entities and patient-related information
 
-These models provide specialized capabilities for medical, coding, and general-purpose tasks.
+These models provide specialized capabilities for medical, coding, NER, and general-purpose tasks.
 
 ## Architecture
 

server.py

@@ -10,6 +10,7 @@ import json
 import asyncio
 from pathlib import Path
 import os
+import re
 
 app = FastAPI(title="Pub/Sub Multi-Agent System")
 
@@ -91,34 +92,89 @@ def create_event(event_type: str, **kwargs):
 def get_llm(model_name: str):
     return Ollama(model=model_name, temperature=0.1)
 
-# Execute agent
-async def execute_agent(agent: Agent, input_content: str, data_sources: List[DataSource], user_question: str) -> str:
-    """Execute a single agent with the given input"""
-    llm = get_llm(agent.model)
+# Check if model is NER model
+def is_ner_model(model_name: str) -> bool:
+    """Check if the model is an NER model"""
+    ner_models = [
+        "samrawal/bert-base-uncased_clinical-ner",
+        "OpenMed/OpenMed-NER-AnatomyDetect-BioPatient-108M"
+    ]
+    return model_name in ner_models
+
+# Format NER output for display
+def format_ner_result(text: str, entities: List[Dict]) -> str:
+    """Format NER entities for human-readable display"""
+    if not entities:
+        return text
     
-    # Start with the base prompt
-    prompt_text = agent.prompt
+    # Sort entities by start position
+    sorted_entities = sorted(entities, key=lambda x: x['start'])
     
-    # Case-insensitive replacement helper
-    def replace_case_insensitive(text: str, placeholder: str, value: str) -> str:
-        """Replace placeholder in text, case insensitive"""
-        import re
-        pattern = re.compile(re.escape(placeholder), re.IGNORECASE)
-        return pattern.sub(value, text)
+    result = []
+    last_end = 0
     
-    # Replace standard placeholders (case insensitive)
-    prompt_text = replace_case_insensitive(prompt_text, "{input}", input_content)
-    prompt_text = replace_case_insensitive(prompt_text, "{question}", user_question)
+    for entity in sorted_entities:
+        # Add text before entity
+        result.append(text[last_end:entity['start']])
+        # Add entity with label
+        result.append(f"[{text[entity['start']:entity['end']]}:{entity['entity_type']}]")
+        last_end = entity['end']
     
-    # Replace data source placeholders (case insensitive)
-    for ds in data_sources:
-        placeholder = "{" + ds.label + "}"
-        prompt_text = replace_case_insensitive(prompt_text, placeholder, ds.content)
+    # Add remaining text
+    result.append(text[last_end:])
     
-    # Invoke LLM
-    result = llm.invoke(prompt_text)
+    return ''.join(result)
+
+# Execute agent
+async def execute_agent(agent: Agent, input_content: str, data_sources: List[DataSource], user_question: str) -> tuple[str, Optional[List[Dict]]]:
+    """Execute a single agent with the given input. Returns (result, entities) where entities is for NER models."""
+    llm = get_llm(agent.model)
     
-    return result if isinstance(result, str) else str(result)
+    # Check if this is an NER model
+    if is_ner_model(agent.model):
+        # For NER models, perform entity recognition
+        # The input should be the text to analyze
+        prompt_text = f"Extract named entities from the following text. Return results as JSON with format: [{{'text': '...', 'entity_type': '...', 'start': int, 'end': int}}]\n\nText: {input_content}"
+        
+        result = llm.invoke(prompt_text)
+        result_str = result if isinstance(result, str) else str(result)
+        
+        # Try to parse JSON result
+        try:
+            # Extract JSON from response (might have extra text)
+            json_match = re.search(r'\[.*\]', result_str, re.DOTALL)
+            if json_match:
+                entities = json.loads(json_match.group())
+                # Return both JSON and entities for NER formatting
+                return result_str, entities
+            else:
+                return result_str, None
+        except:
+            return result_str, None
+    else:
+        # Regular LLM processing
+        # Start with the base prompt
+        prompt_text = agent.prompt
+        
+        # Case-insensitive replacement helper
+        def replace_case_insensitive(text: str, placeholder: str, value: str) -> str:
+            """Replace placeholder in text, case insensitive"""
+            pattern = re.compile(re.escape(placeholder), re.IGNORECASE)
+            return pattern.sub(value, text)
+        
+        # Replace standard placeholders (case insensitive)
+        prompt_text = replace_case_insensitive(prompt_text, "{input}", input_content)
+        prompt_text = replace_case_insensitive(prompt_text, "{question}", user_question)
+        
+        # Replace data source placeholders (case insensitive)
+        for ds in data_sources:
+            placeholder = "{" + ds.label + "}"
+            prompt_text = replace_case_insensitive(prompt_text, placeholder, ds.content)
+        
+        # Invoke LLM
+        result = llm.invoke(prompt_text)
+        
+        return (result if isinstance(result, str) else str(result)), None
 
 # Main execution pipeline
 async def execute_pipeline(request: ExecutionRequest) -> AsyncGenerator[str, None]:
@@ -172,12 +228,17 @@ async def execute_pipeline(request: ExecutionRequest) -> AsyncGenerator[str, Non
                     
                     # Execute agent
                     try:
-                        result = await execute_agent(agent, message_content, request.data_sources, request.user_question)
+                        result, entities = await execute_agent(agent, message_content, request.data_sources, request.user_question)
                         yield create_event("agent_output", content=result)
                         
                         # If agent wants to show result, send it to frontend
                         if agent.show_result:
                             yield create_event("show_result", agent=agent.title, content=result)
+                            
+                            # If this is an NER agent with entities, also send formatted NER result
+                            if entities and is_ner_model(agent.model):
+                                formatted_text = format_ner_result(message_content, entities)
+                                yield create_event("ner_result", agent=agent.title, formatted_text=formatted_text)
                         
                         # Publish result to agent's publish topic (if specified)
                         if agent.publish_topic:

static/index.html

@@ -20,14 +20,18 @@
           const [dataSources, setDataSources] = useState([]);
           const [userQuestion, setUserQuestion] = useState('');
           const [finalResult, setFinalResult] = useState('');
+          const [nerResult, setNerResult] = useState('');
           const [logs, setLogs] = useState('');
           const [isExecuting, setIsExecuting] = useState(false);
+          const [saveResults, setSaveResults] = useState(false);
           const fileInputRef = useRef(null);
 
           const models = [
             "phi3",
             "MedAIBase/MedGemma1.5:4b",
-            "deepseek-coder:1.3b"
+            "deepseek-coder:1.3b",
+            "samrawal/bert-base-uncased_clinical-ner",
+            "OpenMed/OpenMed-NER-AnatomyDetect-BioPatient-108M"
           ];
 
           const addLog = (message, type = 'info') => {
@@ -116,6 +120,15 @@
               }))
             };
 
+            // Add results if checkbox is checked
+            if (saveResults) {
+              config.results = {
+                finalResult: finalResult,
+                nerResult: nerResult,
+                executionLog: logs
+              };
+            }
+
             const blob = new Blob([JSON.stringify(config, null, 2)], { type: 'application/json' });
             const url = URL.createObjectURL(blob);
             const a = document.createElement('a');
@@ -126,7 +139,7 @@
             document.body.removeChild(a);
             URL.revokeObjectURL(url);
             
-            addLog('Configuration saved successfully', 'success');
+            addLog('Configuration saved successfully' + (saveResults ? ' (with results)' : ''), 'success');
           };
 
           const loadConfiguration = (event) => {
@@ -166,9 +179,18 @@
                 }));
                 setAgents(loadedAgents);
 
-                setLogs('');
-                setFinalResult('');
-                addLog(`Configuration loaded: ${loadedDataSources.length} data sources, ${loadedAgents.length} agents`, 'success');
+                // Load results if they exist
+                if (config.results) {
+                  setFinalResult(config.results.finalResult || '');
+                  setNerResult(config.results.nerResult || '');
+                  setLogs(config.results.executionLog || '');
+                  addLog(`Configuration loaded: ${loadedDataSources.length} data sources, ${loadedAgents.length} agents (with saved results)`, 'success');
+                } else {
+                  setLogs('');
+                  setFinalResult('');
+                  setNerResult('');
+                  addLog(`Configuration loaded: ${loadedDataSources.length} data sources, ${loadedAgents.length} agents`, 'success');
+                }
                 
               } catch (error) {
                 addLog(`Failed to load configuration: ${error.message}`, 'error');
@@ -186,6 +208,7 @@
             setIsExecuting(true);
             setLogs('');
             setFinalResult('');
+            setNerResult('');
             
             addLog('Initializing Pub/Sub Agent System...', 'info');
             addLog(`Total agents configured: ${agents.length}`, 'info');
@@ -257,6 +280,11 @@
                           const separator = prev ? '\n\n--- ' + data.agent + ' ---\n\n' : '--- ' + data.agent + ' ---\n\n';
                           return prev + separator + data.content;
                         });
+                      } else if (data.type === 'ner_result') {
+                        setNerResult(prev => {
+                          const separator = prev ? '\n\n--- ' + data.agent + ' ---\n\n' : '--- ' + data.agent + ' ---\n\n';
+                          return prev + separator + data.formatted_text;
+                        });
                       } else if (data.type === 'no_subscribers') {
                         addLog(`No subscribers for topic "${data.topic}"`, 'error');
                       } else if (data.type === 'execution_complete') {
@@ -292,7 +320,19 @@
                     </div>
                     
                     {/* Save/Load Buttons */}
-                    <div className="flex gap-2">
+                    <div className="flex gap-2 items-center">
+                      <div className="flex items-center gap-2 mr-2">
+                        <input
+                          type="checkbox"
+                          id="saveResults"
+                          checked={saveResults}
+                          onChange={(e) => setSaveResults(e.target.checked)}
+                          className="w-4 h-4 text-green-600 focus:ring-green-500 border-gray-300 rounded"
+                        />
+                        <label htmlFor="saveResults" className="text-sm font-medium text-gray-700">
+                          Save results
+                        </label>
+                      </div>
                       <button
                         onClick={saveConfiguration}
                         disabled={agents.length === 0 && dataSources.length === 0}
@@ -532,6 +572,18 @@
 
                   {/* Right Column - Logs and Results */}
                   <div className="space-y-4">
+                    {/* NER Result */}
+                    <div className="bg-white rounded-lg shadow p-4">
+                      <label className="block text-sm font-semibold text-gray-700 mb-2">
+                        🏷️ NER Result
+                      </label>
+                      <div
+                        className="w-full h-48 p-3 border border-gray-300 rounded-lg text-sm bg-yellow-50 overflow-auto whitespace-pre-wrap font-mono"
+                      >
+                        {nerResult || "Named Entity Recognition results will appear here..."}
+                      </div>
+                    </div>
+
                     {/* Final Result */}
                     <div className="bg-white rounded-lg shadow p-4">
                       <label className="block text-sm font-semibold text-gray-700 mb-2">
@@ -553,7 +605,7 @@
                       <textarea
                         value={logs}
                         readOnly
-                        className="w-full h-[calc(100vh-500px)] p-3 border border-gray-300 rounded-lg font-mono text-xs bg-gray-50 focus:outline-none overflow-auto"
+                        className="w-full h-[calc(100vh-800px)] p-3 border border-gray-300 rounded-lg font-mono text-xs bg-gray-50 focus:outline-none overflow-auto"
                         placeholder="Execution logs will appear here when you run the pipeline..."
                       />
                     </div>