Add LLM integration foundation for smart pipeline

- Created agent/llm_client.py - unified client for OpenAI/Anthropic/OpenRouter
- Created agent/consultation.py - interactive multi-turn consultation
- Added PIPELINE_ENHANCEMENT.md with implementation roadmap
- Graceful fallback to mock responses if no API keys
- Ready for hackathon API credits integration

Next steps:
- Add OPENROUTER_API_KEY to .env
- Wire consultation into pipeline
- Enhance SoT generation with real network design
- Add hardware pricing database
- Implement streaming progress updates

PIPELINE_ENHANCEMENT.md

@@ -0,0 +1,285 @@
+# Overgrowth Pipeline Enhancement Plan
+
+## What's Missing (Your Feedback Summary)
+
+1. **❌ No Interactive Consultation** - Should ask follow-up questions
+2. **❌ Source of Truth Incomplete** - No subnets, VLANs, real design
+3. **❌ BOM Pricing Wrong** - Shows $0 for everything
+4. **❌ Setup Guide Generic** - Missing firmware updates, real steps
+5. **❌ No Progress Visibility** - Can't see what AI agents are doing
+6. **❌ No Network Simulation Link** - Should show GNS3 topology
+
+## Implementation Plan
+
+### Phase 1: LLM Integration (PRIORITY)
+
+**Files Created:**
+- `agent/llm_client.py` - Unified LLM client (OpenAI/Anthropic/OpenRouter)
+- `agent/consultation.py` - Interactive multi-turn consultation
+
+**Setup Required:**
+
+```bash
+# Add to .env file:
+OPENROUTER_API_KEY=sk-or-v1-xxxxx  # From your hackathon credits
+# OR
+OPENAI_API_KEY=sk-xxxxx
+# OR
+ANTHROPIC_API_KEY=sk-ant-xxxxx
+```
+
+**Testing:**
+```python
+from agent.consultation import NetworkConsultant
+
+consultant = NetworkConsultant()
+is_complete, output, intent = consultant.start_consultation(
+    "We're a coffee shop chain with 3 locations..."
+)
+print(output)  # Will show follow-up questions
+
+# User answers questions
+is_complete, output, intent = consultant.continue_consultation(
+    "Budget is $50k, need it in 3 months, prefer Ubiquiti gear"
+)
+```
+
+### Phase 2: Smart Network Design
+
+**Enhance `stage2_generate_sot()` in pipeline_engine.py:**
+
+```python
+def stage2_generate_sot(self, intent: NetworkIntent) -> NetworkModel:
+    """Use LLM to design actual network architecture"""
+    
+    prompt = f"""
+    Design a production-ready network for:
+    {intent.description}
+    
+    Requirements:
+    - Budget: {intent.budget}
+    - Locations: {intent.locations}
+    - Compliance: {intent.compliance_requirements}
+    
+    Generate:
+    1. VLAN scheme (management, data, voice, guest, security cameras, POS)
+    2. IP subnetting plan (RFC1918 private addressing)
+    3. Device list (switches, APs, routers, firewalls)
+    4. Routing protocol (static, OSPF, BGP)
+    5. Security policies
+    
+    Return as structured JSON.
+    """
+    
+    # Call LLM to generate real design
+    design = llm.chat([LLMMessage(role="user", content=prompt)])
+    
+    # Parse into NetworkModel
+    return self._parse_network_design(design)
+```
+
+**Example Output:**
+```yaml
+vlans:
+  - id: 10
+    name: Management
+    subnet: 10.0.10.0/24
+  - id: 20
+    name: Guest_WiFi
+    subnet: 10.0.20.0/24
+  - id: 30
+    name: POS_Systems
+    subnet: 10.0.30.0/24
+  - id: 40
+    name: Security_Cameras
+    subnet: 10.0.40.0/24
+
+devices:
+  - name: HQ-Core-SW01
+    role: core
+    model: Ubiquiti USW-Enterprise-48-PoE
+    mgmt_ip: 10.0.10.10
+    interfaces:
+      - name: eth0/1
+        vlan: 10
+        mode: access
+```
+
+### Phase 3: Real BOM Pricing
+
+**Create `agent/hardware_pricing.py`:**
+
+```python
+# Hardware database with real prices
+HARDWARE_DB = {
+    "Ubiquiti USW-Enterprise-48-PoE": {
+        "price": 1799.00,
+        "category": "switch",
+        "vendor": "Ubiquiti"
+    },
+    "Ubiquiti U6-Enterprise": {
+        "price": 379.00,
+        "category": "access_point"
+    },
+    # ... more devices
+}
+
+def calculate_bom_cost(devices: List[Device]) -> float:
+    total = 0
+    for device in devices:
+        if device.model in HARDWARE_DB:
+            total += HARDWARE_DB[device.model]["price"]
+    return total
+```
+
+### Phase 4: Streaming Progress Updates
+
+**Modify `app.py` to use Gradio streaming:**
+
+```python
+def run_pipeline_streaming(user_input):
+    """Stream progress updates to UI"""
+    pipeline = OvergrowthPipeline()
+    
+    # Stage 1: Consultation
+    yield "🤝 Stage 1: Starting consultation...\n"
+    consultant = NetworkConsultant()
+    is_complete, output, intent = consultant.start_consultation(user_input)
+    
+    if not is_complete:
+        yield f"❓ **Follow-up questions:**\n{output}\n\n"
+        # Wait for user response (need UI update for this)
+        return
+    
+    yield f"✅ Stage 1 Complete\n{output}\n\n"
+    
+    # Stage 2: Generate SoT
+    yield "📋 Stage 2: Designing network architecture...\n"
+    model = pipeline.stage2_generate_sot(intent)
+    yield f"✅ Stage 2 Complete - {len(model.devices)} devices, {len(model.vlans)} VLANs\n\n"
+    
+    # Stage 3: Diagrams
+    yield "📊 Stage 3: Generating topology diagrams...\n"
+    diagrams = pipeline.stage3_generate_diagrams(model)
+    yield f"✅ Stage 3 Complete\n\n"
+    
+    # Continue with other stages...
+```
+
+**Update Gradio interface:**
+```python
+run_pipeline_btn.click(
+    fn=run_pipeline_streaming,
+    inputs=[pipeline_input],
+    outputs=[pipeline_status],  # Single streaming output
+    show_progress=True
+)
+```
+
+### Phase 5: GNS3 Simulation Integration
+
+**Add to pipeline results:**
+
+```python
+def stage6_autonomous_deploy(self, model: NetworkModel) -> Dict:
+    """Deploy to GNS3 lab"""
+    from agent.local_mcp import call_tool
+    
+    # Build topology in GNS3
+    result = call_tool("create_project", {
+        "name": model.name,
+        "auto_start": True
+    })
+    
+    project_id = result['project_id']
+    
+    # Add devices
+    for device in model.devices:
+        call_tool("add_node", {
+            "project_id": project_id,
+            "name": device.name,
+            "node_type": device.role,
+            "x": ...,  # Calculate layout
+            "y": ...
+        })
+    
+    # Return simulation URL
+    return {
+        "success": True,
+        "gns3_url": f"http://lab.grahampaasch.com:3080/#/projects/{project_id}",
+        "topology_link": f"View live simulation: {gns3_url}"
+    }
+```
+
+**Display in UI:**
+```markdown
+## 🌐 Live Network Simulation
+
+Your network is being built in GNS3:
+- **Project:** {model.name}
+- **Devices:** {len(model.devices)} nodes
+- **Status:** Deploying...
+
+[View in GNS3](http://lab.grahampaasch.com:3080/#/projects/{project_id})
+```
+
+### Phase 6: Setup Guide with Real Steps
+
+**Enhance `stage5_setup_guide()`:**
+
+```python
+def generate_setup_guide(self, model: NetworkModel) -> SetupGuide:
+    """Generate detailed deployment guide"""
+    
+    phases = [
+        {
+            "name": "Pre-Deployment Validation",
+            "duration": "1 hour",
+            "steps": [
+                "Verify all equipment received matches BOM",
+                "Check firmware versions - minimum required:",
+                *[f"  - {d.model}: firmware v{get_min_firmware(d.model)}" 
+                  for d in model.devices],
+                "Unbox and inventory all equipment",
+                "Download latest firmware if upgrades needed"
+            ]
+        },
+        {
+            "name": "Firmware Updates",
+            "duration": "2-4 hours",
+            "steps": [
+                "Backup factory configs",
+                "Update devices one at a time",
+                *[f"Update {d.name} to {get_latest_firmware(d.model)}" 
+                  for d in model.devices],
+                "Verify boot-up and basic connectivity",
+                "Document firmware versions"
+            ]
+        },
+        # ... more realistic phases
+    ]
+    
+    return SetupGuide(
+        network_name=model.name,
+        phases=phases,
+        # ... other details
+    )
+```
+
+## Next Steps
+
+1. **Add LLM API key to .env**
+2. **Test consultation flow**
+3. **Enhance pipeline stages with LLM calls**
+4. **Add hardware pricing database**
+5. **Implement streaming UI updates**
+6. **Wire up GNS3 deployment**
+
+## Cost Estimate
+
+Using OpenRouter with Claude 3.5 Sonnet:
+- Consultation: ~$0.02 per session
+- Network Design: ~$0.05 per design
+- Total per pipeline run: ~$0.10
+
+Your hackathon credits should cover hundreds of runs.

agent/consultation.py

@@ -0,0 +1,180 @@
+"""
+Interactive Network Consultation
+Multi-turn conversation to gather complete requirements
+"""
+
+import json
+import logging
+from typing import Dict, List, Tuple, Optional
+from agent.llm_client import LLMClient, LLMMessage
+
+logger = logging.getLogger(__name__)
+
+
+CONSULTATION_SYSTEM_PROMPT = """You are an expert network consultant helping a client design their network infrastructure.
+
+Your job is to:
+1. Understand their business needs and technical requirements
+2. Ask clarifying questions to fill in gaps
+3. Probe for important details they may have forgotten (security, compliance, scalability, budget)
+4. Extract structured information: devices needed, VLANs, subnets, bandwidth, redundancy needs
+
+When you have enough information, respond with JSON in this format:
+```json
+{
+  "consultation_complete": true,
+  "network_intent": {
+    "description": "full description",
+    "locations": [...],
+    "business_requirements": [...],
+    "constraints": [...],
+    "timeline": "...",
+    "budget": "...",
+    "vendor_preference": "...",
+    "compliance_requirements": [...],
+    "bandwidth_requirements": {...},
+    "redundancy_requirements": {...}
+  }
+}
+```
+
+If you need more information, respond with:
+```json
+{
+  "consultation_complete": false,
+  "questions": ["question 1", "question 2", ...],
+  "summary_so_far": "what we know so far"
+}
+```
+
+Be professional, thorough, and ask smart questions that a real network consultant would ask.
+"""
+
+
+class NetworkConsultant:
+    """
+    Interactive consultation agent
+    Gathers complete requirements through conversation
+    """
+    
+    def __init__(self):
+        self.llm = LLMClient()
+        self.conversation_history: List[LLMMessage] = []
+        self.intent_data: Optional[Dict] = None
+    
+    def start_consultation(self, initial_description: str) -> Tuple[bool, str, Optional[Dict]]:
+        """
+        Start consultation process
+        Returns: (is_complete, next_questions_or_summary, intent_dict)
+        """
+        # Initialize conversation
+        self.conversation_history = [
+            LLMMessage(role="system", content=CONSULTATION_SYSTEM_PROMPT),
+            LLMMessage(role="user", content=f"Initial request: {initial_description}")
+        ]
+        
+        # Get LLM response
+        response = self.llm.chat(self.conversation_history, temperature=0.3)
+        
+        # Parse response
+        try:
+            # Extract JSON from response
+            json_start = response.find('{')
+            json_end = response.rfind('}') + 1
+            if json_start >= 0 and json_end > json_start:
+                json_str = response[json_start:json_end]
+                result = json.loads(json_str)
+                
+                if result.get("consultation_complete"):
+                    self.intent_data = result.get("network_intent")
+                    summary = self._format_intent_summary(self.intent_data)
+                    return True, summary, self.intent_data
+                else:
+                    questions_text = self._format_questions(result.get("questions", []))
+                    return False, questions_text, None
+            else:
+                # Fallback if no JSON
+                return False, response, None
+                
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse LLM response as JSON: {e}")
+            return False, response, None
+    
+    def continue_consultation(self, user_response: str) -> Tuple[bool, str, Optional[Dict]]:
+        """
+        Continue multi-turn consultation
+        Returns: (is_complete, next_questions_or_summary, intent_dict)
+        """
+        # Add user response to history
+        self.conversation_history.append(
+            LLMMessage(role="user", content=user_response)
+        )
+        
+        # Get LLM response
+        response = self.llm.chat(self.conversation_history, temperature=0.3)
+        self.conversation_history.append(
+            LLMMessage(role="assistant", content=response)
+        )
+        
+        # Parse response
+        try:
+            json_start = response.find('{')
+            json_end = response.rfind('}') + 1
+            if json_start >= 0 and json_end > json_start:
+                json_str = response[json_start:json_end]
+                result = json.loads(json_str)
+                
+                if result.get("consultation_complete"):
+                    self.intent_data = result.get("network_intent")
+                    summary = self._format_intent_summary(self.intent_data)
+                    return True, summary, self.intent_data
+                else:
+                    questions_text = self._format_questions(result.get("questions", []))
+                    summary = result.get("summary_so_far", "")
+                    output = f"**Progress Summary:**\n{summary}\n\n**Additional Questions:**\n{questions_text}"
+                    return False, output, None
+            else:
+                return False, response, None
+                
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse LLM response: {e}")
+            return False, response, None
+    
+    def _format_questions(self, questions: List[str]) -> str:
+        """Format questions as numbered list"""
+        return "\n".join(f"{i+1}. {q}" for i, q in enumerate(questions))
+    
+    def _format_intent_summary(self, intent: Dict) -> str:
+        """Format final intent as readable summary"""
+        lines = ["## 📋 Consultation Complete!\n"]
+        
+        lines.append(f"**Description:** {intent.get('description', 'N/A')}\n")
+        
+        if intent.get('locations'):
+            lines.append(f"**Locations:** {len(intent['locations'])} sites")
+            for loc in intent['locations']:
+                lines.append(f"  - {loc}")
+            lines.append("")
+        
+        if intent.get('business_requirements'):
+            lines.append("**Business Requirements:**")
+            for req in intent['business_requirements']:
+                lines.append(f"  - {req}")
+            lines.append("")
+        
+        if intent.get('budget'):
+            lines.append(f"**Budget:** {intent['budget']}\n")
+        
+        if intent.get('timeline'):
+            lines.append(f"**Timeline:** {intent['timeline']}\n")
+        
+        if intent.get('vendor_preference'):
+            lines.append(f"**Preferred Vendors:** {intent['vendor_preference']}\n")
+        
+        if intent.get('compliance_requirements'):
+            lines.append("**Compliance:**")
+            for req in intent['compliance_requirements']:
+                lines.append(f"  - {req}")
+            lines.append("")
+        
+        return "\n".join(lines)

agent/llm_client.py

@@ -0,0 +1,276 @@
+"""
+LLM Client for Overgrowth Pipeline
+Supports multiple providers: OpenAI, Anthropic, OpenRouter
+"""
+
+import os
+import json
+import logging
+from typing import Dict, List, Optional, Iterator, Any
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LLMMessage:
+    role: str  # system, user, assistant
+    content: str
+
+
+class LLMClient:
+    """
+    Unified LLM client supporting multiple providers
+    Falls back gracefully if API keys not available
+    """
+    
+    def __init__(self):
+        self.openai_key = os.getenv("OPENAI_API_KEY")
+        self.anthropic_key = os.getenv("ANTHROPIC_API_KEY")
+        self.openrouter_key = os.getenv("OPENROUTER_API_KEY")
+        
+        # Determine which provider to use
+        self.provider = self._detect_provider()
+        
+        if self.provider:
+            logger.info(f"LLM client initialized with provider: {self.provider}")
+        else:
+            logger.warning("No LLM API keys found - using mock responses")
+    
+    def _detect_provider(self) -> Optional[str]:
+        """Detect which LLM provider is available"""
+        if self.openrouter_key:
+            return "openrouter"
+        elif self.openai_key:
+            return "openai"
+        elif self.anthropic_key:
+            return "anthropic"
+        return None
+    
+    def chat(
+        self, 
+        messages: List[LLMMessage],
+        temperature: float = 0.7,
+        max_tokens: int = 4000,
+        stream: bool = False
+    ) -> str:
+        """
+        Send chat completion request
+        Returns response text or yields chunks if streaming
+        """
+        if not self.provider:
+            return self._mock_response(messages)
+        
+        if self.provider == "openrouter":
+            return self._call_openrouter(messages, temperature, max_tokens, stream)
+        elif self.provider == "openai":
+            return self._call_openai(messages, temperature, max_tokens, stream)
+        elif self.provider == "anthropic":
+            return self._call_anthropic(messages, temperature, max_tokens, stream)
+    
+    def chat_stream(
+        self,
+        messages: List[LLMMessage],
+        temperature: float = 0.7,
+        max_tokens: int = 4000
+    ) -> Iterator[str]:
+        """Stream chat completion response"""
+        if not self.provider:
+            yield self._mock_response(messages)
+            return
+        
+        if self.provider == "openrouter":
+            yield from self._stream_openrouter(messages, temperature, max_tokens)
+        elif self.provider == "openai":
+            yield from self._stream_openai(messages, temperature, max_tokens)
+        elif self.provider == "anthropic":
+            yield from self._stream_anthropic(messages, temperature, max_tokens)
+    
+    def _call_openrouter(self, messages, temperature, max_tokens, stream):
+        """Call OpenRouter API"""
+        try:
+            import requests
+            
+            url = "https://openrouter.ai/api/v1/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {self.openrouter_key}",
+                "Content-Type": "application/json"
+            }
+            
+            data = {
+                "model": "anthropic/claude-3.5-sonnet",  # Good balance of cost/quality
+                "messages": [{"role": m.role, "content": m.content} for m in messages],
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            response = requests.post(url, headers=headers, json=data, timeout=60)
+            response.raise_for_status()
+            
+            return response.json()['choices'][0]['message']['content']
+            
+        except Exception as e:
+            logger.error(f"OpenRouter API error: {e}")
+            return self._mock_response(messages)
+    
+    def _stream_openrouter(self, messages, temperature, max_tokens):
+        """Stream from OpenRouter"""
+        try:
+            import requests
+            
+            url = "https://openrouter.ai/api/v1/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {self.openrouter_key}",
+                "Content-Type": "application/json"
+            }
+            
+            data = {
+                "model": "anthropic/claude-3.5-sonnet",
+                "messages": [{"role": m.role, "content": m.content} for m in messages],
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+                "stream": True
+            }
+            
+            with requests.post(url, headers=headers, json=data, stream=True, timeout=60) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    if line:
+                        line = line.decode('utf-8')
+                        if line.startswith('data: '):
+                            line = line[6:]
+                            if line == '[DONE]':
+                                break
+                            try:
+                                chunk = json.loads(line)
+                                if 'choices' in chunk and len(chunk['choices']) > 0:
+                                    delta = chunk['choices'][0].get('delta', {})
+                                    if 'content' in delta:
+                                        yield delta['content']
+                            except json.JSONDecodeError:
+                                continue
+                                
+        except Exception as e:
+            logger.error(f"OpenRouter streaming error: {e}")
+            yield self._mock_response(messages)
+    
+    def _call_openai(self, messages, temperature, max_tokens, stream):
+        """Call OpenAI API"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=self.openai_key)
+            
+            response = client.chat.completions.create(
+                model="gpt-4o",
+                messages=[{"role": m.role, "content": m.content} for m in messages],
+                temperature=temperature,
+                max_tokens=max_tokens
+            )
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            logger.error(f"OpenAI API error: {e}")
+            return self._mock_response(messages)
+    
+    def _stream_openai(self, messages, temperature, max_tokens):
+        """Stream from OpenAI"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=self.openai_key)
+            
+            stream = client.chat.completions.create(
+                model="gpt-4o",
+                messages=[{"role": m.role, "content": m.content} for m in messages],
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=True
+            )
+            
+            for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    yield chunk.choices[0].delta.content
+                    
+        except Exception as e:
+            logger.error(f"OpenAI streaming error: {e}")
+            yield self._mock_response(messages)
+    
+    def _call_anthropic(self, messages, temperature, max_tokens, stream):
+        """Call Anthropic API"""
+        try:
+            import anthropic
+            client = anthropic.Anthropic(api_key=self.anthropic_key)
+            
+            # Convert messages format
+            system_msg = None
+            user_messages = []
+            for m in messages:
+                if m.role == "system":
+                    system_msg = m.content
+                else:
+                    user_messages.append({"role": m.role, "content": m.content})
+            
+            response = client.messages.create(
+                model="claude-3-5-sonnet-20241022",
+                max_tokens=max_tokens,
+                temperature=temperature,
+                system=system_msg if system_msg else "You are a helpful network automation assistant.",
+                messages=user_messages
+            )
+            
+            return response.content[0].text
+            
+        except Exception as e:
+            logger.error(f"Anthropic API error: {e}")
+            return self._mock_response(messages)
+    
+    def _stream_anthropic(self, messages, temperature, max_tokens):
+        """Stream from Anthropic"""
+        try:
+            import anthropic
+            client = anthropic.Anthropic(api_key=self.anthropic_key)
+            
+            # Convert messages format
+            system_msg = None
+            user_messages = []
+            for m in messages:
+                if m.role == "system":
+                    system_msg = m.content
+                else:
+                    user_messages.append({"role": m.role, "content": m.content})
+            
+            with client.messages.stream(
+                model="claude-3-5-sonnet-20241022",
+                max_tokens=max_tokens,
+                temperature=temperature,
+                system=system_msg if system_msg else "You are a helpful network automation assistant.",
+                messages=user_messages
+            ) as stream:
+                for text in stream.text_stream:
+                    yield text
+                    
+        except Exception as e:
+            logger.error(f"Anthropic streaming error: {e}")
+            yield self._mock_response(messages)
+    
+    def _mock_response(self, messages: List[LLMMessage]) -> str:
+        """Return mock response when no API key available"""
+        last_user_msg = next((m.content for m in reversed(messages) if m.role == "user"), "")
+        
+        if "consultation" in last_user_msg.lower():
+            return json.dumps({
+                "questions": [
+                    "What is your total budget for this network deployment?",
+                    "Do you have any vendor preferences? (Cisco, Juniper, Arista, Ubiquiti, MikroTik)",
+                    "When do you need this network operational?",
+                    "Do you have existing infrastructure to integrate with?",
+                    "What are your bandwidth requirements per location?"
+                ],
+                "clarifications": [
+                    "How many total concurrent devices across all 3 locations?",
+                    "Do you need site-to-site VPN between locations?",
+                    "PCI-DSS compliance required for payment processing?"
+                ]
+            })
+        
+        return "Mock LLM response - please configure API keys"