commit 9

.gitignore

@@ -1,3 +1,5 @@
 *.db
 /graph-agentic-system/neo4j/data
 /neo4j/data
+/postgres/data
+/neo4j/logs

Makefile

@@ -1,11 +1,89 @@
+.PHONY: up down logs seed clean health test demo
+
+# Start all services
 up:
 	docker-compose up -d
+	@echo "Waiting for services to be healthy..."
+	@sleep 10
+	@make health
 
+# Stop all services
 down:
 	docker-compose down
 
+# View logs
 logs:
 	docker-compose logs -f
 
+# Seed initial data
 seed:
-	docker-compose exec mcp python /app/ops/scripts/seed.py
+	docker-compose exec mcp python /app/ops/scripts/seed.py
+
+# Clean everything (including volumes)
+clean:
+	docker-compose down -v
+	docker system prune -f
+	@if [ -d "neo4j/data" ]; then rm -rf neo4j/data; fi
+	@if [ -d "postgres/data" ]; then rm -rf postgres/data; fi
+	@if [ -d "frontend/.next" ]; then rm -rf frontend/.next; fi
+	@if [ -d "frontend/node_modules" ]; then rm -rf frontend/node_modules; fi
+
+# Health check all services
+health:
+	@echo "Checking service health..."
+	@docker-compose exec neo4j cypher-shell -u neo4j -p password "MATCH (n) RETURN count(n) LIMIT 1" > /dev/null 2>&1 && echo "✅ Neo4j: Healthy" || echo "❌ Neo4j: Unhealthy"
+	@docker-compose exec postgres pg_isready -U postgres > /dev/null 2>&1 && echo "✅ PostgreSQL: Healthy" || echo "❌ PostgreSQL: Unhealthy"
+	@curl -s http://localhost:8000/health > /dev/null && echo "✅ MCP Server: Healthy" || echo "❌ MCP Server: Unhealthy"
+	@curl -s http://localhost:3000 > /dev/null && echo "✅ Frontend: Healthy" || echo "❌ Frontend: Unhealthy"
+	@docker-compose ps agent | grep -q "Up" && echo "✅ Agent: Running" || echo "❌ Agent: Not running"
+
+# Run integration test
+test: health
+	@echo "Running integration test..."
+	@make seed
+	@sleep 5
+	@echo "Check http://localhost:3000 and Neo4j Browser at http://localhost:7474"
+
+# Demo workflow
+demo:
+	@echo "Starting demo workflow..."
+	@make clean
+	@make up
+	@make seed
+	@echo ""
+	@echo "🎉 Demo Ready!"
+	@echo "1. Open http://localhost:3000 in your browser"
+	@echo "2. Ask a question like: 'Show me all customers who have placed orders'"
+	@echo "3. Watch the agent process through the workflow"
+	@echo "4. Check Neo4j Browser at http://localhost:7474 (neo4j/password)"
+	@echo ""
+	@echo "During 5-minute pauses, you can edit instructions in Neo4j Browser:"
+	@echo "MATCH (i:Instruction {status: 'pending'}) SET i.parameters = '{\"question\": \"new question\"}'"
+
+# Build all services
+build:
+	docker-compose build
+
+# Restart specific service
+restart-agent:
+	docker-compose restart agent
+
+restart-mcp:
+	docker-compose restart mcp
+
+restart-frontend:
+	docker-compose restart frontend
+
+# Debug commands
+debug-agent:
+	docker-compose logs agent
+
+debug-mcp:
+	docker-compose logs mcp
+
+debug-frontend:
+	docker-compose logs frontend
+
+# Quick status check
+status:
+	docker-compose ps

README.md

@@ -1,80 +1,299 @@
-# Agentic Knowledge Graph
+# Graph-Driven Agentic System MVP
 
-A graph-driven agentic system that uses Neo4j as the knowledge graph backend, with MCP server for graph operations, an intelligent agent for workflow execution, and a web interface for interaction.
+## Overview
+An intelligent agent system that reads instructions from Neo4j, queries PostgreSQL databases, pauses for human review, and maintains a complete audit trail. The system demonstrates agentic workflow orchestration with human-in-the-loop controls.
+
+## Key Features
+
+🤖 **Autonomous Agent**: Processes instructions sequentially with configurable pause durations  
+📊 **Graph Database**: All workflow metadata stored in Neo4j for complete traceability  
+🔍 **Natural Language SQL**: Converts questions to SQL using LLM integration  
+⏸️ **Human-in-the-Loop**: 5-minute pauses allow instruction editing during execution  
+🎯 **Single API Gateway**: All Neo4j operations routed through MCP server  
+📈 **Real-time Visualization**: Live workflow progress in browser interface  
+🔄 **Complete Audit Trail**: Every action logged with timestamps and relationships  
 
 ## Architecture
 
-- **Neo4j**: Knowledge graph database storing workflows, instructions, and metadata
-- **MCP Server**: Single gateway for all Neo4j operations with API key authentication
-- **Agent**: Executes workflows by reading instructions from Neo4j and performing actions
-- **Frontend**: Next.js web interface for user interaction and monitoring
-- **PostgreSQL**: Data source for schema discovery and query execution
+```
+┌─────────────┐    ┌─────────────┐    ┌─────────────┐
+│   Frontend  │────│ MCP Server  │────│    Neo4j    │
+│  (Next.js)  │    │ (FastAPI)   │    │  (Graph)    │
+└─────────────┘    └─────────────┘    └─────────────┘
+                           │
+                    ┌─────────────┐    ┌─────────────┐
+                    │    Agent    │────│ PostgreSQL  │
+                    │  (Python)   │    │   (Data)    │
+                    └─────────────┘    └─────────────┘
+```
+
+### Components
+
+- **Neo4j**: Graph database storing workflows, instructions, and execution metadata
+- **MCP Server**: Single gateway for all Neo4j operations with parameter fixing
+- **Agent**: Executes instructions with configurable pause periods for human review
+- **PostgreSQL**: Sample data source for testing SQL generation
+- **Frontend**: React/Next.js chat interface with real-time workflow visualization
 
 ## Quick Start
 
-1. **Clone and setup**:
+### Prerequisites
+- Docker & Docker Compose
+- OpenAI or Anthropic API key (for LLM integration)
+
+### Setup
+1. **Clone and configure**:
    ```bash
    git clone <repository-url>
-   cd 20250922_agentic_kg
+   cd <repository-name>
    cp .env.example .env
    ```
 
-2. **Edit environment variables**:
-   - Update `.env` with your API keys and configuration
-   - Set `LLM_API_KEY` for OpenAI/Claude access
-   - Set `MCP_API_KEYS` for MCP server authentication
+2. **Add your LLM API key** to `.env`:
+   ```bash
+   # For OpenAI
+   LLM_API_KEY=sk-your-openai-key-here
+   LLM_MODEL=gpt-4
 
-3. **Start services**:
+   # For Anthropic  
+   LLM_API_KEY=your-anthropic-key-here
+   LLM_MODEL=claude-3-sonnet-20240229
+   ```
+
+3. **Start the system**:
    ```bash
    make up
    ```
 
-4. **Check health**:
+4. **Seed demo data**:
    ```bash
-   make neo4j-health
-   make logs
+   make seed
    ```
 
-## Available Commands
+5. **Open the interface**:
+   - Frontend: http://localhost:3000
+   - Neo4j Browser: http://localhost:7474 (neo4j/password)
+
+## Usage
+
+### Basic Workflow
+1. **Ask a question** in the chat interface:
+   - "How many customers do we have?"
+   - "Show me all customers who have placed orders"
+   - "What's the total revenue?"
+
+2. **Watch the agent process**:
+   - Creates workflow with 3 instructions
+   - Discovers database schema
+   - Generates SQL from your question
+   - Reviews and formats results
+
+3. **Human intervention** (during 5-minute pauses):
+   - Edit instructions in Neo4j Browser
+   - Change parameters or questions
+   - Stop workflows if needed
+
+### Editing Instructions During Pause
+
+When the agent pauses, you can modify instructions in Neo4j Browser:
+
+```cypher
+// Change the question being asked
+MATCH (i:Instruction {status: 'pending'}) 
+SET i.parameters = '{"question": "Show me customers from the last month"}'
 
-- `make up` - Start all services
-- `make down` - Stop all services  
-- `make logs` - Show service logs
-- `make seed` - Seed database with initial data
-- `make clean` - Stop and remove volumes
-- `make restart` - Restart all services
-- `make neo4j-health` - Check Neo4j health
+// Stop the entire workflow
+MATCH (w:Workflow {status: 'active'}) 
+SET w.status = 'stopped'
+```
+
+### Monitoring
+
+Check system health:
+```bash
+make health
+```
+
+View real-time logs:
+```bash
+make logs
+```
+
+Check specific service:
+```bash
+make debug-agent    # Agent logs
+make debug-mcp      # MCP server logs  
+make debug-frontend # Frontend logs
+```
+
+## Commands Reference
 
-## Services
+| Command | Description |
+|---------|-------------|
+| `make up` | Start all services |
+| `make down` | Stop all services |
+| `make clean` | Remove all data and containers |
+| `make health` | Check service health |
+| `make seed` | Create demo data |
+| `make logs` | View all logs |
+| `make demo` | Full clean + setup + seed |
+| `make test` | Run integration test |
 
-- **Neo4j**: http://localhost:7474 (Browser), bolt://localhost:7687 (Bolt)
-- **MCP Server**: http://localhost:3001
-- **Frontend**: http://localhost:3000
-- **PostgreSQL**: localhost:5432
+## Configuration
+
+### Environment Variables
+
+All configuration is in `.env` file:
+
+- **Neo4j**: Database connection and auth
+- **PostgreSQL**: Sample data source  
+- **MCP**: API keys and server settings
+- **Agent**: Polling interval and pause duration
+- **LLM**: API key and model selection
+
+### Pause Duration
+
+Default: 5 minutes (300 seconds)
+Configurable via `PAUSE_DURATION` in `.env`
+
+### Polling Interval  
+
+Default: 30 seconds
+Configurable via `AGENT_POLL_INTERVAL` in `.env`
 
 ## Development
 
-The system is designed as a monorepo with the following structure:
+### File Structure
+```
+├── agent/          # Python agent that executes instructions
+├── frontend/       # Next.js chat interface  
+├── mcp/           # FastAPI server for Neo4j operations
+├── neo4j/         # Neo4j configuration and data
+├── postgres/      # PostgreSQL setup and sample data
+├── ops/           # Operational scripts (seeding, etc.)
+├── docker-compose.yml
+├── Makefile
+└── README.md
+```
+
+### Adding New Instruction Types
+
+1. **Define handler in agent**:
+   ```python
+   def handle_new_instruction_type(instruction):
+       # Implementation
+       return {"status": "success", "result": "..."}
+   ```
+
+2. **Add to agent main loop**:
+   ```python
+   elif instruction['type'] == 'new_instruction_type':
+       exec_result = handle_new_instruction_type(instruction)
+   ```
+
+3. **Update frontend** to create new instruction types in workflows.
+
+### Database Schema
+
+The system uses two databases:
+
+**Neo4j** (Workflow metadata):
+- `Workflow` nodes with status and metadata
+- `Instruction` nodes with type, sequence, parameters
+- `Execution` nodes with results and timestamps  
+- Relationships: `HAS_INSTRUCTION`, `EXECUTED_AS`, `NEXT_INSTRUCTION`
+
+**PostgreSQL** (Sample data):
+- `customers` table
+- `orders` table
+- Sample data for testing SQL generation
+
+## Troubleshooting
+
+### Common Issues
+
+**Services not starting**:
+```bash
+make down
+make clean  
+make up
+```
+
+**Agent not processing**:
+```bash
+make restart-agent
+make debug-agent
+```
+
+**Frontend not loading**:
+```bash
+make restart-frontend
+make debug-frontend  
+```
 
+**Database connection issues**:
+```bash
+make health
+# Check .env configuration
 ```
-├── neo4j/          # Neo4j Docker configuration
-├── mcp/            # MCP server implementation
-├── agent/          # Agent implementation
-├── frontend/       # Next.js frontend
-├── postgres/       # PostgreSQL configuration
-├── ops/            # Operations scripts
-└── docker-compose.yml
+
+### Debug Mode
+
+For detailed logging, check individual service logs:
+```bash
+docker-compose logs -f agent
+docker-compose logs -f mcp
+docker-compose logs -f frontend
 ```
 
-## Features
+### Reset Everything
+
+Complete clean slate:
+```bash
+make clean
+cp .env.example .env  
+# Edit .env with your API key
+make demo
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Test with `make demo`
+4. Submit a pull request
+
+## License
 
-- Graph-driven workflow execution
-- Human-in-the-loop pauses for review
-- Natural language to SQL translation
-- Real-time workflow monitoring
-- Graph visualization
-- Audit logging
+MIT License - see LICENSE file for details.
+
+---
+
+## Quick Demo
+
+Want to see it in action immediately?
+
+```bash
+# 1. Clone repo
+git clone <repo-url> && cd <repo-name>
+
+# 2. Add your API key  
+cp .env.example .env
+# Edit .env: LLM_API_KEY=your-key-here
+
+# 3. Start everything
+make demo
+
+# 4. Open http://localhost:3000
+# 5. Ask: "How many records are in the database?"
+# 6. Watch the magic happen! ✨
+```
 
-## Status
+The system will:
+- Create a workflow with 3 instructions
+- Pause for 5 minutes before each step (editable in Neo4j Browser)
+- Generate SQL from your natural language question
+- Execute the query and return formatted results
+- Show the entire process in a visual graph
 
-🚧 **In Development** - Core infrastructure setup complete, implementing MCP server and agent components.
+🎉 **Welcome to the future of human-AI collaboration!**

agent/Dockerfile

@@ -5,6 +5,7 @@ WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY main.py .
+COPY . .
 
-CMD ["python", "main.py"]
+# Use unbuffered output to see logs in real-time
+CMD ["python", "-u", "main.py"]

docker-compose.yml

@@ -4,63 +4,86 @@ services:
   neo4j:
     build: ./neo4j
     ports:
-      - "7474:7474"  # Browser
-      - "7687:7687"  # Bolt
+      - "7474:7474"
+      - "7687:7687"
     environment:
-      - NEO4J_AUTH=neo4j/password
+      - NEO4J_AUTH=${NEO4J_AUTH}
     volumes:
       - ./neo4j/data:/data
+      - ./neo4j/logs:/logs
     healthcheck:
       test: ["CMD", "cypher-shell", "-u", "neo4j", "-p", "password", "MATCH (n) RETURN count(n) LIMIT 1"]
       interval: 10s
       timeout: 5s
       retries: 5
+    networks:
+      - agent-network
 
   postgres:
     image: postgres:15
-    container_name: postgres
-    ports:
-      - "5432:5432"
     environment:
       - POSTGRES_DB=testdb
       - POSTGRES_USER=postgres
       - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+    ports:
+      - "5432:5432"
     volumes:
-      - postgres_data:/var/lib/postgresql/data
+      - ./postgres/data:/var/lib/postgresql/data
       - ./postgres/init.sql:/docker-entrypoint-initdb.d/init.sql
     healthcheck:
       test: ["CMD-SHELL", "pg_isready -U postgres"]
       interval: 10s
       timeout: 5s
       retries: 5
+    networks:
+      - agent-network
 
   mcp:
     build: ./mcp
-    container_name: mcp
     ports:
       - "8000:8000"
     environment:
-      - MCP_PORT=8000
-      - MCP_API_KEYS=dev-key-123,external-key-456
-      - NEO4J_BOLT_URL=bolt://neo4j:7687
-      - NEO4J_AUTH=neo4j/password
-      - POSTGRES_CONNECTION=postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/testdb
+      - NEO4J_BOLT_URL=${NEO4J_BOLT_URL}
+      - NEO4J_AUTH=${NEO4J_AUTH}
+      - POSTGRES_CONNECTION=${POSTGRES_CONNECTION}
+      - MCP_API_KEYS=${MCP_API_KEYS}
+      - MCP_PORT=${MCP_PORT}
     depends_on:
-      - neo4j
-      - postgres
+      neo4j:
+        condition: service_healthy
+      postgres:
+        condition: service_healthy
+    volumes:
+      - ./mcp:/app
+      - ./ops/scripts:/app/ops/scripts
+    command: uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - agent-network
 
   agent:
     build: ./agent
-    container_name: agent
     environment:
       - MCP_URL=http://mcp:8000/mcp
       - MCP_API_KEY=dev-key-123
-      - AGENT_POLL_INTERVAL=${AGENT_POLL_INTERVAL:-30}
+      - AGENT_POLL_INTERVAL=${AGENT_POLL_INTERVAL}
+      - PAUSE_DURATION=${PAUSE_DURATION}
       - LLM_API_KEY=${LLM_API_KEY}
-      - LLM_MODEL=${LLM_MODEL:-gpt-4}
+      - LLM_MODEL=${LLM_MODEL}
+      - POSTGRES_CONNECTION=${POSTGRES_CONNECTION}
     depends_on:
-      - mcp
-      - neo4j
+      mcp:
+        condition: service_healthy
+    volumes:
+      - ./agent:/app
+    command: python -u main.py
+    restart: unless-stopped
+    networks:
+      - agent-network
 
   frontend:
     build: ./frontend
@@ -70,7 +93,14 @@ services:
       - NEXT_PUBLIC_MCP_URL=http://localhost:8000
     depends_on:
       - mcp
+    volumes:
+      - ./frontend:/app
+      - /app/node_modules
+      - /app/.next
+    command: npm run dev
+    networks:
+      - agent-network
 
-volumes:
-  neo4j_data:
-  postgres_data:
+networks:
+  agent-network:
+    driver: bridge

frontend/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

frontend/tsconfig.json

@@ -1,7 +1,11 @@
 {
   "compilerOptions": {
     "target": "es5",
-    "lib": ["dom", "dom.iterable", "esnext"],
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
     "allowJs": true,
     "skipLibCheck": true,
     "strict": true,
@@ -16,9 +20,24 @@
     "incremental": true,
     "baseUrl": ".",
     "paths": {
-      "@/*": ["./*"]
-    }
+      "@/*": [
+        "./*"
+      ]
+    },
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ]
   },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", "types/**/*.d.ts"],
-  "exclude": ["node_modules"]
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    "types/**/*.d.ts",
+    ".next/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
 }

mcp/Dockerfile

@@ -2,11 +2,13 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
+# Install curl for healthcheck
+RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
 EXPOSE 8000
-
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

ops/scripts/seed.py

@@ -1,10 +1,20 @@
+#!/usr/bin/env python3
+"""
+Seed script to create demo data for the agentic system.
+Creates a sample workflow with instructions for testing.
+"""
+
 import requests
 import json
+import time
+import os
 
-MCP_URL = "http://mcp:8000/mcp"
-API_KEY = "dev-key-123"
+# Configuration
+MCP_URL = os.getenv("MCP_URL", "http://localhost:8000/mcp")
+API_KEY = os.getenv("MCP_API_KEY", "dev-key-123")
 
 def call_mcp(tool, params=None):
+    """Call the MCP API"""
     response = requests.post(
         MCP_URL,
         headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
@@ -12,83 +22,190 @@ def call_mcp(tool, params=None):
     )
     return response.json()
 
-# Create demo workflow
-workflow = call_mcp("write_graph", {
-    "action": "create_node",
-    "label": "Workflow",
-    "properties": {
-        "id": "demo-workflow-1",
-        "name": "Entity Resolution Demo",
-        "status": "active",
-        "max_iterations": 10,
-        "current_iteration": 0
-    }
-})
-print(f"Created workflow: {workflow}")
-
-# Create three instructions
-instructions = [
-    {
-        "id": "inst-1", 
-        "sequence": 1, 
-        "type": "discover_schema", 
-        "status": "pending", 
-        "pause_duration": 300,
-        "parameters": "{}"
-    },
-    {
-        "id": "inst-2", 
-        "sequence": 2, 
-        "type": "generate_sql", 
-        "status": "pending", 
-        "pause_duration": 300,
-        "parameters": json.dumps({"question": "Show all customers who have placed orders"})
-    },
-    {
-        "id": "inst-3", 
-        "sequence": 3, 
-        "type": "review_results", 
-        "status": "pending", 
-        "pause_duration": 300,
-        "parameters": "{}"
-    }
-]
-
-for inst in instructions:
-    result = call_mcp("write_graph", {
+def create_demo_workflow():
+    """Create a demo workflow for testing"""
+    print("🌱 Seeding demo data...")
+    
+    # Create demo workflow
+    workflow_result = call_mcp("write_graph", {
         "action": "create_node",
-        "label": "Instruction",
-        "properties": inst
+        "label": "Workflow",
+        "properties": {
+            "id": "demo-workflow-1",
+            "name": "Entity Resolution Demo",
+            "description": "Demo workflow showing SQL generation and execution",
+            "status": "active",
+            "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ")
+        }
     })
-    print(f"Created instruction: {inst['id']}")
     
-    # Link to workflow
-    call_mcp("query_graph", {
+    if 'created' not in workflow_result:
+        print(f"❌ Failed to create workflow: {workflow_result}")
+        return False
+    
+    print("✅ Created demo workflow")
+    
+    # Create demo instructions
+    instructions = [
+        {
+            "id": "demo-inst-1",
+            "type": "discover_schema",
+            "sequence": 1,
+            "description": "Discover database schema",
+            "parameters": "{}"
+        },
+        {
+            "id": "demo-inst-2", 
+            "type": "generate_sql",
+            "sequence": 2,
+            "description": "Generate SQL for customer orders",
+            "parameters": json.dumps({
+                "question": "Show me all customers who have placed orders, including their order details"
+            })
+        },
+        {
+            "id": "demo-inst-3",
+            "type": "review_results", 
+            "sequence": 3,
+            "description": "Review and format results",
+            "parameters": "{}"
+        }
+    ]
+    
+    for inst in instructions:
+        inst_result = call_mcp("write_graph", {
+            "action": "create_node",
+            "label": "Instruction",
+            "properties": {
+                "id": inst["id"],
+                "type": inst["type"],
+                "sequence": inst["sequence"],
+                "description": inst["description"],
+                "status": "pending",
+                "pause_duration": 300,  # 5 minutes
+                "parameters": inst["parameters"],
+                "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ")
+            }
+        })
+        
+        if 'created' not in inst_result:
+            print(f"❌ Failed to create instruction {inst['id']}: {inst_result}")
+            continue
+            
+        # Link instruction to workflow
+        link_result = call_mcp("query_graph", {
+            "query": "MATCH (w:Workflow), (i:Instruction) WHERE w.id = wid AND i.id = iid CREATE (w)-[:HAS_INSTRUCTION]->(i)",
+            "parameters": {"wid": "demo-workflow-1", "iid": inst["id"]}
+        })
+        
+        print(f"✅ Created instruction: {inst['type']}")
+    
+    # Create instruction chain
+    for i in range(len(instructions) - 1):
+        current_id = instructions[i]["id"]
+        next_id = instructions[i + 1]["id"]
+        
+        chain_result = call_mcp("query_graph", {
+            "query": "MATCH (i1:Instruction), (i2:Instruction) WHERE i1.id = id1 AND i2.id = id2 CREATE (i1)-[:NEXT_INSTRUCTION]->(i2)",
+            "parameters": {"id1": current_id, "id2": next_id}
+        })
+    
+    print("✅ Created instruction chain")
+    
+    # Create query templates for demo
+    templates = [
+        {
+            "id": "template-1",
+            "question": "How many customers do we have?",
+            "query": "SELECT COUNT(*) as customer_count FROM customers"
+        },
+        {
+            "id": "template-2", 
+            "question": "Show me recent orders",
+            "query": "SELECT o.id, o.order_date, c.name FROM orders o JOIN customers c ON o.customer_id = c.id ORDER BY o.order_date DESC LIMIT 10"
+        },
+        {
+            "id": "template-3",
+            "question": "What's the total revenue?", 
+            "query": "SELECT SUM(total_amount) as total_revenue FROM orders"
+        }
+    ]
+    
+    for template in templates:
+        template_result = call_mcp("write_graph", {
+            "action": "create_node",
+            "label": "QueryTemplate",
+            "properties": {
+                "id": template["id"],
+                "question": template["question"],
+                "query": template["query"],
+                "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ")
+            }
+        })
+    
+    print("✅ Created query templates")
+    
+    # Verify the setup
+    verification = call_mcp("query_graph", {
         "query": """
-            MATCH (w:Workflow {id: $wid}), (i:Instruction {id: $iid})
-            CREATE (w)-[:HAS_INSTRUCTION]->(i)
+            MATCH (w:Workflow {id: 'demo-workflow-1'})-[:HAS_INSTRUCTION]->(i:Instruction)
+            RETURN w.name, count(i) as instruction_count
         """,
-        "parameters": {"wid": "demo-workflow-1", "iid": inst['id']}
+        "parameters": {}
     })
+    
+    if verification.get('data'):
+        workflow_name = verification['data'][0]['w.name']
+        instruction_count = verification['data'][0]['instruction_count']
+        print(f"✅ Verification: '{workflow_name}' with {instruction_count} instructions")
+    
+    print("🎉 Demo data seeded successfully!")
+    print("\n📋 Next steps:")
+    print("1. Open http://localhost:3000 in your browser")
+    print("2. Ask a question like: 'Show me all customers who have placed orders'")
+    print("3. Watch the agent process the workflow")
+    print("4. During the 5-minute pause, you can edit instructions in Neo4j Browser")
+    print("5. Neo4j Browser: http://localhost:7474 (username: neo4j, password: password)")
+    
+    return True
 
-# Create instruction chain
-call_mcp("query_graph", {
-    "query": """
-        MATCH (i1:Instruction {id: 'inst-1'}), (i2:Instruction {id: 'inst-2'})
-        CREATE (i1)-[:NEXT_INSTRUCTION]->(i2)
-    """
-})
-
-call_mcp("query_graph", {
-    "query": """
-        MATCH (i2:Instruction {id: 'inst-2'}), (i3:Instruction {id: 'inst-3'})
-        CREATE (i2)-[:NEXT_INSTRUCTION]->(i3)
-    """
-})
-
-# Create indexes
-call_mcp("query_graph", {"query": "CREATE INDEX workflow_id IF NOT EXISTS FOR (w:Workflow) ON (w.id)"})
-call_mcp("query_graph", {"query": "CREATE INDEX instruction_id IF NOT EXISTS FOR (i:Instruction) ON (i.id)"})
-call_mcp("query_graph", {"query": "CREATE INDEX instruction_status_seq IF NOT EXISTS FOR (i:Instruction) ON (i.status, i.sequence)"})
+def check_services():
+    """Check if required services are available"""
+    try:
+        # Check MCP health
+        health_response = requests.get(f"{MCP_URL.replace('/mcp', '/health')}", timeout=5)
+        if health_response.status_code != 200:
+            print("❌ MCP service not available")
+            return False
+            
+        # Check MCP API
+        test_response = requests.post(
+            MCP_URL,
+            headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
+            json={"tool": "get_schema"},
+            timeout=5
+        )
+        if test_response.status_code != 200:
+            print("❌ MCP API not responding")
+            return False
+            
+        print("✅ Services are available")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Service check failed: {e}")
+        return False
 
-print("✅ Seeding complete!")
+if __name__ == "__main__":
+    print("🚀 Starting seed process...")
+    
+    if not check_services():
+        print("❌ Cannot proceed - services not available")
+        exit(1)
+    
+    if create_demo_workflow():
+        print("✅ Seed completed successfully")
+        exit(0)
+    else:
+        print("❌ Seed failed")
+        exit(1)