Update mcp_server.py

mcp_server.py

@@ -1,37 +1,153 @@
 """
 MCP Server for Second Opinion AI Agent
 Provides tools for analyzing ideas, detecting biases, and generating alternatives
+Tools use LLM to generate context-aware responses based on user input
 """
 
 from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, Field
 from typing import List, Dict, Optional, Literal
 import json
+import os
 from datetime import datetime
 
 # Initialize FastMCP server
 mcp = FastMCP("second-opinion-tools")
 
-class IdeaAnalysis(BaseModel):
-    """Model for idea analysis input"""
-    idea: str = Field(..., description="The idea or decision to analyze")
-    context: Optional[str] = Field(None, description="Additional context or background")
-    goals: Optional[List[str]] = Field(None, description="Stated goals or objectives")
-
-class BiasDetection(BaseModel):
-    """Model for bias detection results"""
-    bias_type: str
-    description: str
-    evidence: str
-    severity: Literal["low", "medium", "high"]
-
-class Alternative(BaseModel):
-    """Model for alternative solutions"""
-    title: str
-    description: str
-    pros: List[str]
-    cons: List[str]
-    feasibility: Literal["low", "medium", "high"]
+# =============================================================================
+# LLM INTEGRATION FOR CONTEXTUAL ANALYSIS
+# =============================================================================
+
+def get_llm_client():
+    """Get an LLM client based on available API keys"""
+    # Try Google Gemini first (often has free tier)
+    google_key = os.environ.get("GOOGLE_API_KEY")
+    if google_key:
+        try:
+            import google.generativeai as genai
+            genai.configure(api_key=google_key)
+            return ("gemini", genai)
+        except ImportError:
+            pass
+    
+    # Try OpenAI
+    openai_key = os.environ.get("OPENAI_API_KEY")
+    if openai_key:
+        try:
+            from openai import OpenAI
+            return ("openai", OpenAI(api_key=openai_key))
+        except ImportError:
+            pass
+    
+    # Try Anthropic
+    anthropic_key = os.environ.get("ANTHROPIC_API_KEY")
+    if anthropic_key:
+        try:
+            import anthropic
+            return ("anthropic", anthropic.Anthropic(api_key=anthropic_key))
+        except ImportError:
+            pass
+    
+    return (None, None)
+
+
+def call_llm(prompt: str, max_tokens: int = 2000) -> str:
+    """Call the available LLM with a prompt"""
+    provider, client = get_llm_client()
+    
+    if provider is None:
+        return None  # No LLM available, will fall back to template
+    
+    try:
+        if provider == "gemini":
+            model = client.GenerativeModel("gemini-2.0-flash-lite")
+            response = model.generate_content(prompt)
+            return response.text
+        
+        elif provider == "openai":
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=max_tokens,
+                temperature=0.7
+            )
+            return response.choices[0].message.content
+        
+        elif provider == "anthropic":
+            response = client.messages.create(
+                model="claude-haiku-4-5-20251001",
+                max_tokens=max_tokens,
+                messages=[{"role": "user", "content": prompt}]
+            )
+            return response.content[0].text
+    
+    except Exception as e:
+        print(f"LLM call failed: {e}")
+        return None
+    
+    return None
+
+
+def generate_contextual_analysis(tool_name: str, idea: str, extra_context: str, 
+                                  analysis_prompt: str, fallback_template: dict) -> str:
+    """
+    Generate contextual analysis using LLM, with fallback to template.
+    
+    Args:
+        tool_name: Name of the tool for logging
+        idea: The user's idea to analyze
+        extra_context: Additional context provided by user
+        analysis_prompt: The specific prompt for this analysis type
+        fallback_template: Template to use if LLM is unavailable
+    
+    Returns:
+        JSON string with analysis results
+    """
+    full_prompt = f"""{analysis_prompt}
+
+IDEA TO ANALYZE:
+{idea}
+
+{f"ADDITIONAL CONTEXT: {extra_context}" if extra_context else ""}
+
+Respond with a valid JSON object only. No markdown, no code blocks, just the JSON."""
+
+    llm_response = call_llm(full_prompt)
+    
+    if llm_response:
+        # Try to parse as JSON, clean up if needed
+        try:
+            # Remove markdown code blocks if present
+            cleaned = llm_response.strip()
+            if cleaned.startswith("```"):
+                cleaned = cleaned.split("\n", 1)[1]  # Remove first line
+                if cleaned.endswith("```"):
+                    cleaned = cleaned.rsplit("```", 1)[0]
+            cleaned = cleaned.strip()
+            
+            # Validate it's JSON
+            parsed = json.loads(cleaned)
+            parsed["_generated"] = "contextual"
+            parsed["timestamp"] = datetime.now().isoformat()
+            return json.dumps(parsed, indent=2)
+        except json.JSONDecodeError:
+            # If not valid JSON, wrap the response
+            return json.dumps({
+                "timestamp": datetime.now().isoformat(),
+                "_generated": "contextual",
+                "analysis": llm_response
+            }, indent=2)
+    
+    # Fallback to template
+    fallback_template["_generated"] = "template"
+    fallback_template["timestamp"] = datetime.now().isoformat()
+    fallback_template["idea_analyzed"] = idea[:200] + "..." if len(idea) > 200 else idea
+    return json.dumps(fallback_template, indent=2)
+
+
+# =============================================================================
+# MCP TOOLS
+# =============================================================================
 
 @mcp.tool()
 def analyze_assumptions(idea: str, context: str = "") -> str:
@@ -46,39 +162,46 @@ def analyze_assumptions(idea: str, context: str = "") -> str:
         JSON string containing identified assumptions, their implications, and questions to verify them
     """
     
-    analysis = {
-        "timestamp": datetime.now().isoformat(),
-        "idea_summary": idea[:200] + "..." if len(idea) > 200 else idea,
-        "analysis": {
-            "explicit_assumptions": [
-                "Assumptions that are stated directly in the idea"
-            ],
-            "implicit_assumptions": [
-                "Assumptions that are implied but not stated",
-                "Hidden premises that need to be examined"
-            ],
-            "foundational_beliefs": [
-                "Core beliefs this idea rests upon",
-                "Worldview assumptions"
-            ],
-            "contextual_assumptions": [
-                "Assumptions about the environment",
-                "Assumptions about timing and conditions"
-            ]
-        },
-        "verification_questions": [
-            "What evidence supports this assumption?",
-            "What if this assumption is wrong?",
-            "Under what conditions would this assumption fail?"
-        ],
-        "recommendations": [
-            "Test key assumptions before proceeding",
-            "Identify which assumptions are most critical",
-            "Create contingency plans for false assumptions"
-        ]
+    analysis_prompt = """You are an expert critical thinking analyst. Analyze the given idea to identify ALL assumptions - both explicit and hidden.
+
+Your analysis must be specific to this exact idea. Identify:
+1. Explicit assumptions stated directly
+2. Implicit/hidden assumptions not stated but required for the idea to work
+3. Foundational beliefs the idea rests upon
+4. Contextual assumptions about timing, market, resources, etc.
+
+For each assumption, explain:
+- What the assumption is
+- Why it matters
+- What happens if it's wrong
+- How to verify it
+
+Return a JSON object with this structure:
+{
+    "idea_summary": "brief summary of the idea",
+    "explicit_assumptions": [
+        {"assumption": "...", "importance": "high/medium/low", "verification": "how to test this"}
+    ],
+    "hidden_assumptions": [
+        {"assumption": "...", "why_hidden": "...", "risk_if_wrong": "..."}
+    ],
+    "foundational_beliefs": ["belief 1", "belief 2"],
+    "critical_questions": ["question 1", "question 2", "question 3"],
+    "highest_risk_assumption": "the assumption most likely to be wrong or cause failure"
+}"""
+
+    fallback = {
+        "explicit_assumptions": ["Unable to analyze - LLM not available"],
+        "hidden_assumptions": ["Please check API key configuration"],
+        "foundational_beliefs": [],
+        "critical_questions": [],
+        "highest_risk_assumption": "Analysis unavailable"
     }
     
-    return json.dumps(analysis, indent=2)
+    return generate_contextual_analysis(
+        "analyze_assumptions", idea, context, analysis_prompt, fallback
+    )
+
 
 @mcp.tool()
 def detect_cognitive_biases(idea: str, reasoning: str = "") -> str:
@@ -93,71 +216,56 @@ def detect_cognitive_biases(idea: str, reasoning: str = "") -> str:
         JSON string containing detected biases, their descriptions, and mitigation strategies
     """
     
-    common_biases = {
-        "confirmation_bias": {
-            "name": "Confirmation Bias",
-            "description": "Tendency to search for or interpret information that confirms existing beliefs",
-            "indicators": ["cherry-picking data", "ignoring contradictory evidence"],
-            "severity": "high"
-        },
-        "anchoring_bias": {
-            "name": "Anchoring Bias",
-            "description": "Over-reliance on the first piece of information encountered",
-            "indicators": ["fixating on initial numbers", "difficulty adjusting from first impression"],
-            "severity": "medium"
-        },
-        "sunk_cost_fallacy": {
-            "name": "Sunk Cost Fallacy",
-            "description": "Continuing a course of action due to previously invested resources",
-            "indicators": ["'we've come too far to turn back'", "justifying based on past investment"],
-            "severity": "high"
-        },
-        "availability_bias": {
-            "name": "Availability Bias",
-            "description": "Overestimating likelihood of events based on recent or memorable examples",
-            "indicators": ["relying on anecdotes", "recent events driving decisions"],
-            "severity": "medium"
-        },
-        "optimism_bias": {
-            "name": "Optimism Bias",
-            "description": "Overestimating positive outcomes and underestimating risks",
-            "indicators": ["'it won't happen to us'", "underestimating complexity"],
-            "severity": "high"
-        },
-        "groupthink": {
-            "name": "Groupthink",
-            "description": "Desire for harmony leads to poor decision-making",
-            "indicators": ["suppressing dissent", "illusion of unanimity"],
-            "severity": "high"
+    analysis_prompt = """You are a cognitive bias expert. Analyze the given idea and reasoning to detect specific cognitive biases that may be affecting the thinking.
+
+Look for evidence of these common biases:
+- Confirmation bias (seeking confirming evidence)
+- Anchoring bias (over-relying on first information)
+- Sunk cost fallacy (continuing due to past investment)
+- Availability bias (overweighting recent/memorable events)
+- Optimism bias (underestimating risks)
+- Survivorship bias (only seeing successes)
+- Dunning-Kruger effect (overestimating competence)
+- Status quo bias (preferring current state)
+- Bandwagon effect (following the crowd)
+- Recency bias (overweighting recent events)
+
+For each bias detected, provide SPECIFIC evidence from the idea/reasoning.
+
+Return a JSON object with this structure:
+{
+    "idea_summary": "brief summary",
+    "detected_biases": [
+        {
+            "bias_name": "name of bias",
+            "evidence": "specific quote or aspect that shows this bias",
+            "severity": "high/medium/low",
+            "how_it_distorts": "how this bias is affecting the decision"
         }
+    ],
+    "most_concerning_bias": "the bias most likely to lead to a bad decision",
+    "debiasing_strategies": [
+        "specific action to counter the biases found"
+    ],
+    "questions_to_ask": [
+        "question that would help overcome these biases"
+    ]
+}"""
+
+    fallback = {
+        "detected_biases": [{"bias_name": "Analysis unavailable", "evidence": "LLM not configured", "severity": "unknown"}],
+        "most_concerning_bias": "Unable to analyze",
+        "debiasing_strategies": ["Check API configuration"],
+        "questions_to_ask": []
     }
     
-    analysis = {
-        "timestamp": datetime.now().isoformat(),
-        "detected_biases": list(common_biases.values()),
-        "mitigation_strategies": [
-            "Actively seek disconfirming evidence",
-            "Consult diverse perspectives",
-            "Use pre-mortem analysis (imagine failure)",
-            "Set decision criteria before gathering information",
-            "Assign someone to play devil's advocate"
-        ],
-        "debiasing_questions": [
-            "What evidence would change my mind?",
-            "Am I being overconfident?",
-            "What am I not seeing?",
-            "Would I make this decision if starting fresh today?"
-        ]
-    }
-    
-    return json.dumps(analysis, indent=2)
+    return generate_contextual_analysis(
+        "detect_cognitive_biases", idea, reasoning, analysis_prompt, fallback
+    )
+
 
 @mcp.tool()
-def generate_alternatives(
-    idea: str,
-    constraints: str = "",
-    num_alternatives: int = 5
-) -> str:
+def generate_alternatives(idea: str, constraints: str = "", num_alternatives: int = 5) -> str:
     """
     Generates alternative approaches and solutions to consider.
     
@@ -170,105 +278,50 @@ def generate_alternatives(
         JSON string containing diverse alternative approaches with pros/cons analysis
     """
     
-    alternatives = {
-        "original_idea": idea[:200] + "..." if len(idea) > 200 else idea,
-        "constraints": constraints,
-        "alternatives": [
-            {
-                "id": 1,
-                "title": "Incremental Approach",
-                "description": "Break down the idea into smaller, testable steps",
-                "pros": [
-                    "Lower risk",
-                    "Learn as you go",
-                    "Can pivot based on feedback"
-                ],
-                "cons": [
-                    "Slower to full implementation",
-                    "May lose momentum",
-                    "Partial solutions might not prove value"
-                ],
-                "feasibility": "high"
-            },
-            {
-                "id": 2,
-                "title": "Opposite Approach",
-                "description": "Consider doing the exact opposite of the proposed idea",
-                "pros": [
-                    "Reveals hidden assumptions",
-                    "May uncover better path",
-                    "Challenges conventional thinking"
-                ],
-                "cons": [
-                    "May seem counterintuitive",
-                    "Requires reframing problem",
-                    "Not always applicable"
-                ],
-                "feasibility": "medium"
-            },
-            {
-                "id": 3,
-                "title": "Hybrid Solution",
-                "description": "Combine elements from multiple approaches",
-                "pros": [
-                    "Balances trade-offs",
-                    "Leverages strengths of each",
-                    "More flexible"
-                ],
-                "cons": [
-                    "Can be complex",
-                    "May lack clear focus",
-                    "Harder to execute"
-                ],
-                "feasibility": "medium"
-            },
-            {
-                "id": 4,
-                "title": "Wait and Learn",
-                "description": "Delay decision while gathering more information",
-                "pros": [
-                    "Reduces uncertainty",
-                    "Market may validate/invalidate",
-                    "More data for better decision"
-                ],
-                "cons": [
-                    "Opportunity cost",
-                    "Competitive disadvantage",
-                    "Analysis paralysis risk"
-                ],
-                "feasibility": "high"
-            },
-            {
-                "id": 5,
-                "title": "Minimum Viable Approach",
-                "description": "Find the simplest possible version that tests key assumptions",
-                "pros": [
-                    "Fast to implement",
-                    "Low resource commitment",
-                    "Quick validation"
-                ],
-                "cons": [
-                    "May not fully represent vision",
-                    "Limited scope",
-                    "Could underestimate true potential"
-                ],
-                "feasibility": "high"
-            }
-        ][:num_alternatives],
-        "evaluation_framework": {
-            "criteria": [
-                "Alignment with goals",
-                "Risk level",
-                "Resource requirements",
-                "Time to value",
-                "Reversibility",
-                "Learning potential"
-            ],
-            "process": "Score each alternative 1-10 on each criterion, then compare"
-        }
+    num_alternatives = max(1, min(10, num_alternatives))
+    
+    analysis_prompt = f"""You are a creative strategist. Generate {num_alternatives} genuinely different alternatives to the proposed idea.
+
+Don't just tweak the original - think of fundamentally different approaches that could achieve similar goals.
+
+Consider:
+- What if we did the opposite?
+- What's the minimum viable version?
+- What would a 10x version look like?
+- How would different industries solve this?
+- What if we removed a key constraint?
+
+{f"CONSTRAINTS TO WORK WITHIN: {constraints}" if constraints else ""}
+
+Return a JSON object with this structure:
+{{
+    "original_idea_summary": "brief summary of original",
+    "goal_identified": "the underlying goal this idea is trying to achieve",
+    "alternatives": [
+        {{
+            "name": "descriptive name",
+            "description": "what this alternative involves",
+            "how_different": "how this differs from the original",
+            "pros": ["advantage 1", "advantage 2"],
+            "cons": ["disadvantage 1", "disadvantage 2"],
+            "feasibility": "high/medium/low",
+            "best_if": "scenario where this alternative would be best"
+        }}
+    ],
+    "recommended_alternative": "which alternative seems most promising and why",
+    "hybrid_suggestion": "how to combine elements from multiple alternatives"
+}}"""
+
+    fallback = {
+        "original_idea_summary": "Analysis unavailable",
+        "alternatives": [{"name": "LLM not available", "description": "Please configure API keys"}],
+        "recommended_alternative": "Unable to analyze"
     }
     
-    return json.dumps(alternatives, indent=2)
+    return generate_contextual_analysis(
+        "generate_alternatives", idea, constraints, analysis_prompt, fallback
+    )
+
 
 @mcp.tool()
 def perform_premortem_analysis(idea: str, timeframe: str = "1 year") -> str:
@@ -283,76 +336,56 @@ def perform_premortem_analysis(idea: str, timeframe: str = "1 year") -> str:
         JSON string containing potential failure modes, warning signs, and preventive measures
     """
     
-    premortem = {
-        "timestamp": datetime.now().isoformat(),
-        "scenario": f"Imagine it's {timeframe} from now, and this idea has failed completely",
-        "failure_modes": [
-            {
-                "category": "Execution Failures",
-                "scenarios": [
-                    "Team lacked necessary skills",
-                    "Underestimated complexity and timeline",
-                    "Poor communication led to misalignment",
-                    "Key person left at critical moment"
-                ]
-            },
-            {
-                "category": "Market/External Failures",
-                "scenarios": [
-                    "Market conditions changed unexpectedly",
-                    "Competitor launched better solution first",
-                    "Customer needs were misunderstood",
-                    "Regulatory changes blocked approach"
-                ]
-            },
-            {
-                "category": "Strategic Failures",
-                "scenarios": [
-                    "Solving the wrong problem",
-                    "Solution didn't address root cause",
-                    "Opportunity cost was too high",
-                    "Failed to achieve minimum viable scale"
-                ]
-            },
-            {
-                "category": "Resource Failures",
-                "scenarios": [
-                    "Ran out of budget before completion",
-                    "Couldn't secure necessary partnerships",
-                    "Technical infrastructure couldn't scale",
-                    "Dependencies failed or were delayed"
-                ]
-            }
-        ],
-        "early_warning_signs": [
-            "Metrics trending wrong direction",
-            "Increasing resistance or skepticism",
-            "Scope creep and deadline slips",
-            "Key assumptions proving false",
-            "Team morale declining"
-        ],
-        "preventive_measures": [
-            "Define clear success metrics upfront",
-            "Build in checkpoints for go/no-go decisions",
-            "Create contingency plans for top 3 risks",
-            "Establish kill criteria before starting",
-            "Schedule regular assumption testing"
-        ],
-        "questions_to_answer": [
-            "What would need to be true for this to succeed?",
-            "What's our plan if X fails?",
-            "How will we know if we're on the wrong path?",
-            "What's our exit strategy?"
-        ]
+    analysis_prompt = f"""You are a risk analyst performing a pre-mortem analysis. Imagine it's {timeframe} from now and this idea has COMPLETELY FAILED.
+
+Your job is to work backwards and identify all the reasons why it failed. Be specific to THIS idea - don't give generic failure modes.
+
+Consider failures in:
+- Execution (team, skills, timeline)
+- Market/External factors (competition, regulation, timing)
+- Strategy (wrong problem, wrong solution)
+- Resources (money, people, technology)
+- Assumptions (what turned out to be wrong)
+
+Return a JSON object with this structure:
+{{
+    "scenario": "It's {timeframe} from now, and the idea has failed because...",
+    "primary_cause_of_failure": "the single biggest reason it failed",
+    "failure_modes": [
+        {{
+            "category": "execution/market/strategy/resources/assumptions",
+            "what_went_wrong": "specific failure",
+            "probability": "high/medium/low",
+            "impact": "catastrophic/major/moderate/minor"
+        }}
+    ],
+    "early_warning_signs": [
+        "specific signal that would indicate this failure is coming"
+    ],
+    "preventive_actions": [
+        {{
+            "action": "what to do now",
+            "prevents": "which failure mode this addresses"
+        }}
+    ],
+    "kill_criteria": "conditions under which you should abandon this idea",
+    "plan_b": "what to do if this fails"
+}}"""
+
+    fallback = {
+        "scenario": f"Analysis for {timeframe} timeframe unavailable",
+        "failure_modes": [{"category": "unknown", "what_went_wrong": "LLM not configured"}],
+        "early_warning_signs": [],
+        "preventive_actions": []
     }
     
-    return json.dumps(premortem, indent=2)
+    return generate_contextual_analysis(
+        "perform_premortem_analysis", idea, timeframe, analysis_prompt, fallback
+    )
+
 
 @mcp.tool()
-def identify_stakeholders_and_impacts(
-    idea: str,
-    organization_context: str = ""
-) -> str:
+def identify_stakeholders_and_impacts(idea: str, organization_context: str = "") -> str:
     """
     Identifies all stakeholders and analyzes potential impacts on each group.
     
@@ -364,105 +397,58 @@ def identify_stakeholders_and_impacts(
         JSON string containing stakeholder analysis with impacts, concerns, and engagement strategies
     """
     
-    analysis = {
-        "timestamp": datetime.now().isoformat(),
-        "stakeholder_groups": [
-            {
-                "group": "Direct Users/Customers",
-                "impact_level": "high",
-                "potential_impacts": [
-                    "Changed user experience or workflow",
-                    "New learning curve required",
-                    "Value proposition shift"
-                ],
-                "likely_concerns": [
-                    "Will this make things better or worse?",
-                    "How much effort to adapt?",
-                    "What if I don't like it?"
-                ],
-                "engagement_strategy": "Early involvement, clear communication, feedback loops"
-            },
-            {
-                "group": "Implementation Team",
-                "impact_level": "high",
-                "potential_impacts": [
-                    "Additional workload",
-                    "New skills required",
-                    "Changed priorities"
-                ],
-                "likely_concerns": [
-                    "Do we have capacity?",
-                    "What gets deprioritized?",
-                    "Is timeline realistic?"
-                ],
-                "engagement_strategy": "Involve in planning, realistic scoping, adequate resources"
-            },
-            {
-                "group": "Leadership/Decision Makers",
-                "impact_level": "medium",
-                "potential_impacts": [
-                    "Resource allocation decisions",
-                    "Strategic direction implications",
-                    "Risk exposure"
-                ],
-                "likely_concerns": [
-                    "What's the ROI?",
-                    "What are the risks?",
-                    "How does this fit strategy?"
-                ],
-                "engagement_strategy": "Business case, risk mitigation plan, metrics"
-            },
-            {
-                "group": "Adjacent Teams/Partners",
-                "impact_level": "medium",
-                "potential_impacts": [
-                    "Workflow dependencies",
-                    "Integration requirements",
-                    "Coordination overhead"
-                ],
-                "likely_concerns": [
-                    "How does this affect our work?",
-                    "What do we need to change?",
-                    "Were we consulted?"
-                ],
-                "engagement_strategy": "Early coordination, clear interfaces, collaborative planning"
-            },
-            {
-                "group": "Competitors/Market",
-                "impact_level": "low",
-                "potential_impacts": [
-                    "Competitive dynamics shift",
-                    "Market expectations change",
-                    "Industry standards affected"
-                ],
-                "likely_concerns": [
-                    "How to respond?",
-                    "Is this a threat or opportunity?"
-                ],
-                "engagement_strategy": "Market monitoring, strategic positioning"
-            }
-        ],
-        "overlooked_stakeholders": [
-            "Consider: Who maintains this long-term?",
-            "Consider: Who pays for this?",
-            "Consider: Who gets blamed if it fails?",
-            "Consider: Whose job becomes harder/easier?"
-        ],
-        "conflict_analysis": {
-            "potential_conflicts": [
-                "Short-term costs vs long-term benefits",
-                "Individual convenience vs collective good",
-                "Innovation speed vs risk management"
-            ],
-            "resolution_approaches": [
-                "Transparent trade-off discussions",
-                "Pilot programs to demonstrate value",
-                "Phased rollout to manage change"
-            ]
+    analysis_prompt = """You are a stakeholder analysis expert. Identify ALL parties who will be affected by this idea - both obvious and non-obvious stakeholders.
+
+For each stakeholder, analyze:
+- How they'll be impacted (positively or negatively)
+- What their likely concerns will be
+- Whether they have power to help or block this
+- How to engage them effectively
+
+Don't forget often-overlooked stakeholders like:
+- People who maintain/support this long-term
+- Those whose workload changes
+- Competitors and their customers
+- Regulators or compliance teams
+- Future employees/customers
+
+Return a JSON object with this structure:
+{
+    "idea_summary": "brief summary",
+    "stakeholders": [
+        {
+            "group": "stakeholder name",
+            "relationship": "how they relate to this idea",
+            "impact": "positive/negative/mixed",
+            "impact_description": "specific ways they're affected",
+            "likely_concerns": ["concern 1", "concern 2"],
+            "power_level": "high/medium/low",
+            "engagement_strategy": "how to work with them"
+        }
+    ],
+    "most_affected": "who has the most at stake",
+    "potential_blockers": ["stakeholders who might resist"],
+    "potential_champions": ["stakeholders who might advocate"],
+    "conflicts_to_manage": [
+        {
+            "between": "stakeholder A vs stakeholder B",
+            "conflict": "what they disagree about",
+            "resolution_approach": "how to address"
         }
+    ],
+    "stakeholder_not_consulted": "who should be involved but often isn't"
+}"""
+
+    fallback = {
+        "stakeholders": [{"group": "Analysis unavailable", "impact": "unknown"}],
+        "most_affected": "Unable to analyze",
+        "conflicts_to_manage": []
     }
     
-    return json.dumps(analysis, indent=2)
+    return generate_contextual_analysis(
+        "identify_stakeholders_and_impacts", idea, organization_context, analysis_prompt, fallback
+    )
+
 
 @mcp.tool()
 def second_order_thinking(idea: str, time_horizon: str = "2-5 years") -> str:
@@ -477,77 +463,75 @@ def second_order_thinking(idea: str, time_horizon: str = "2-5 years") -> str:
         JSON string containing cascade of consequences and system-level effects
     """
     
-    analysis = {
-        "timestamp": datetime.now().isoformat(),
-        "time_horizon": time_horizon,
-        "consequence_cascade": {
-            "first_order": {
-                "description": "Immediate, direct effects",
-                "examples": [
-                    "Direct impact on users/customers",
-                    "Immediate resource requirements",
-                    "Initial results or outcomes"
-                ]
-            },
-            "second_order": {
-                "description": "Effects of the first-order effects",
-                "examples": [
-                    "How do people adapt to the change?",
-                    "What new behaviors emerge?",
-                    "What dependencies are created?",
-                    "What gets easier/harder as a result?"
-                ]
-            },
-            "third_order": {
-                "description": "Systemic shifts and long-term transformations",
-                "examples": [
-                    "How does culture or mindset shift?",
-                    "What new equilibrium is reached?",
-                    "What irreversible changes occur?",
-                    "What becomes possible/impossible?"
-                ]
-            }
-        },
-        "unintended_consequences": {
-            "positive": [
-                "Unexpected benefits that may emerge",
-                "Side effects that create value elsewhere",
-                "Learning and capability building"
-            ],
-            "negative": [
-                "Perverse incentives created",
-                "Workarounds that undermine intent",
-                "Dependencies that create fragility",
-                "Race conditions or competitive dynamics"
-            ]
-        },
-        "feedback_loops": {
-            "reinforcing": [
-                "What positive feedback loops could accelerate this?",
-                "What could spiral out of control?"
-            ],
-            "balancing": [
-                "What natural limits exist?",
-                "What forces will push back?"
-            ]
-        },
-        "questions_to_explore": [
-            "If this succeeds, then what?",
-            "What happens when everyone does this?",
-            "What does this make inevitable?",
-            "What does this make obsolete?",
-            "What new problems does this create?"
-        ]
+    analysis_prompt = f"""You are a systems thinker analyzing cascading consequences. For the given idea, think through what happens AFTER the immediate effects.
+
+First-order effects are obvious. Your job is to find the second, third, and nth-order effects that aren't obvious.
+
+Think about:
+- How will people ADAPT to this change?
+- What new behaviors will emerge?
+- What feedback loops will be created?
+- What becomes possible that wasn't before?
+- What becomes impossible?
+- What unintended consequences might occur?
+
+Time horizon to consider: {time_horizon}
+
+Return a JSON object with this structure:
+{{
+    "idea_summary": "brief summary",
+    "first_order_effects": [
+        "immediate, obvious consequence 1",
+        "immediate, obvious consequence 2"
+    ],
+    "second_order_effects": [
+        {{
+            "effect": "what happens as a result of first-order effects",
+            "caused_by": "which first-order effect leads to this",
+            "timeline": "when this would manifest"
+        }}
+    ],
+    "third_order_effects": [
+        {{
+            "effect": "deeper consequence",
+            "chain": "first order -> second order -> this",
+            "probability": "high/medium/low"
+        }}
+    ],
+    "feedback_loops": [
+        {{
+            "type": "reinforcing/balancing",
+            "description": "what cycle gets created",
+            "implication": "why this matters"
+        }}
+    ],
+    "unintended_consequences": [
+        {{
+            "consequence": "what might happen unexpectedly",
+            "positive_or_negative": "positive/negative",
+            "how_to_monitor": "how to detect this early"
+        }}
+    ],
+    "what_becomes_possible": ["new opportunity 1"],
+    "what_becomes_impossible": ["closed door 1"],
+    "biggest_long_term_risk": "the consequence most likely to cause regret"
+}}"""
+
+    fallback = {
+        "first_order_effects": ["Analysis unavailable - LLM not configured"],
+        "second_order_effects": [],
+        "third_order_effects": [],
+        "feedback_loops": [],
+        "unintended_consequences": []
     }
     
-    return json.dumps(analysis, indent=2)
+    return generate_contextual_analysis(
+        "second_order_thinking", idea, time_horizon, analysis_prompt, fallback
+    )
+
 
 @mcp.tool()
-def opportunity_cost_analysis(
-    idea: str,
-    resources: str = "",
-    alternatives: str = ""
-) -> str:
+def opportunity_cost_analysis(idea: str, resources: str = "", alternatives: str = "") -> str:
     """
     Analyzes opportunity costs: what you give up by choosing this path.
     
@@ -560,75 +544,72 @@ def opportunity_cost_analysis(
         JSON string containing opportunity cost analysis and trade-off framework
     """
     
-    analysis = {
-        "timestamp": datetime.now().isoformat(),
-        "core_concept": "Opportunity cost is what you give up when you choose one option over another",
-        "resource_commitments": {
-            "time": {
-                "direct_time": "Time spent implementing this idea",
-                "opportunity_cost": "What else could be done with that time?",
-                "questions": [
-                    "Is this the highest-value use of our time?",
-                    "What are we NOT doing by doing this?"
-                ]
-            },
-            "money": {
-                "direct_cost": "Financial investment required",
-                "opportunity_cost": "Alternative investments or savings",
-                "questions": [
-                    "What else could this money fund?",
-                    "What's the expected return compared to alternatives?"
-                ]
-            },
-            "attention": {
-                "direct_cost": "Mental energy and focus required",
-                "opportunity_cost": "Other priorities that get less attention",
-                "questions": [
-                    "What falls through the cracks?",
-                    "Where should attention be focused?"
-                ]
-            },
-            "reputation": {
-                "direct_cost": "Credibility and social capital at stake",
-                "opportunity_cost": "Political capital spent, trust consumed",
-                "questions": [
-                    "What if this fails publicly?",
-                    "Is this worth spending reputation on?"
-                ]
-            }
-        },
-        "trade_off_framework": {
-            "explicit_trade_offs": [
-                "What are we openly choosing to sacrifice?",
-                "What constraints are we accepting?"
-            ],
-            "implicit_trade_offs": [
-                "What are we giving up without realizing it?",
-                "What doors close by choosing this path?"
-            ],
-            "reversibility": [
-                "Can we undo this decision later?",
-                "What becomes locked in?",
-                "What optionality do we lose?"
-            ]
+    extra_context = f"Resources available: {resources}\nAlternatives mentioned: {alternatives}" if resources or alternatives else ""
+    
+    analysis_prompt = """You are an economist analyzing opportunity costs. For every choice, something is given up. Identify what's being sacrificed by pursuing this idea.
+
+Consider opportunity costs across:
+- Time (what else could this time be spent on?)
+- Money (what else could this money fund?)
+- Attention (what gets less focus?)
+- Talent (what else could these people work on?)
+- Reputation (what credibility is at stake?)
+- Optionality (what future choices are foreclosed?)
+
+Be specific to this idea - what are the ACTUAL trade-offs?
+
+Return a JSON object with this structure:
+{
+    "idea_summary": "brief summary",
+    "resource_commitments": {
+        "time": {
+            "amount": "estimated time commitment",
+            "opportunity_cost": "what else could be done with this time",
+            "is_worth_it": "yes/no/uncertain with reasoning"
         },
-        "better_alternatives_test": {
-            "questions": [
-                "If we had unlimited time/money, would we still choose this?",
-                "What would we do if this option didn't exist?",
-                "Is there a 10x better option we're not seeing?",
-                "Are we settling for local maximum?"
-            ]
+        "money": {
+            "amount": "estimated financial commitment",
+            "opportunity_cost": "alternative uses for this money",
+            "is_worth_it": "yes/no/uncertain with reasoning"
         },
-        "recommendations": [
-            "List out what you're explicitly NOT doing",
-            "Quantify opportunity costs where possible",
-            "Consider: is this a reversible decision?",
-            "Ask: what keeps us from doing this AND something else?"
-        ]
+        "attention": {
+            "amount": "how much focus this requires",
+            "opportunity_cost": "what gets deprioritized",
+            "is_worth_it": "yes/no/uncertain with reasoning"
+        }
+    },
+    "doors_that_close": [
+        "option that becomes unavailable by choosing this"
+    ],
+    "hidden_costs": [
+        "cost that isn't obvious upfront"
+    ],
+    "reversibility": {
+        "is_reversible": "yes/partially/no",
+        "cost_to_reverse": "what it would take to undo this",
+        "point_of_no_return": "when does this become irreversible"
+    },
+    "better_uses_of_resources": [
+        {
+            "alternative": "what else you could do",
+            "expected_value": "potential outcome",
+            "why_not_doing_this": "reason this might not be chosen"
+        }
+    ],
+    "key_question": "the most important trade-off question to answer before proceeding"
+}"""
+
+    fallback = {
+        "resource_commitments": {"time": {"opportunity_cost": "Analysis unavailable"}},
+        "doors_that_close": [],
+        "hidden_costs": [],
+        "reversibility": {"is_reversible": "unknown"}
     }
     
-    return json.dumps(analysis, indent=2)
+    return generate_contextual_analysis(
+        "opportunity_cost_analysis", idea, extra_context, analysis_prompt, fallback
+    )
+
 
 @mcp.tool()
 def red_team_analysis(idea: str, attack_surface: str = "") -> str:
@@ -643,92 +624,73 @@ def red_team_analysis(idea: str, attack_surface: str = "") -> str:
         JSON string containing attack vectors, vulnerabilities, and defensive measures
     """
     
-    analysis = {
-        "timestamp": datetime.now().isoformat(),
-        "red_team_mindset": "Assume adversarial intent. How can this be broken, gamed, or exploited?",
-        "attack_vectors": [
-            {
-                "category": "Incentive Manipulation",
-                "attacks": [
-                    "How can users game the system?",
-                    "What perverse incentives does this create?",
-                    "How could metrics be manipulated?",
-                    "What loopholes exist?"
-                ]
-            },
-            {
-                "category": "Technical Vulnerabilities",
-                "attacks": [
-                    "What breaks at scale?",
-                    "Where are single points of failure?",
-                    "What assumptions break under stress?",
-                    "What's the weakest link?"
-                ]
-            },
-            {
-                "category": "Economic Attacks",
-                "attacks": [
-                    "How could competitors undermine this?",
-                    "What's the economic incentive to break it?",
-                    "How can value be extracted unfairly?",
-                    "What arbitrage opportunities exist?"
-                ]
-            },
-            {
-                "category": "Social Engineering",
-                "attacks": [
-                    "How can trust be exploited?",
-                    "What social dynamics undermine intent?",
-                    "How can this be weaponized?",
-                    "What could go viral in bad ways?"
-                ]
-            },
-            {
-                "category": "Edge Cases",
-                "attacks": [
-                    "What happens at extremes?",
-                    "What if 1000x more users?",
-                    "What if all users do X at once?",
-                    "What breaks the model?"
-                ]
-            }
-        ],
-        "defensive_measures": {
-            "prevention": [
-                "Design out vulnerabilities",
-                "Limit attack surface",
-                "Build in circuit breakers",
-                "Rate limiting and quotas"
-            ],
-            "detection": [
-                "Monitor for anomalies",
-                "Set up alerts for abuse patterns",
-                "Track leading indicators",
-                "Regular security audits"
-            ],
-            "response": [
-                "Incident response plan",
-                "Ability to roll back quickly",
-                "Clear escalation paths",
-                "Communication strategy"
-            ]
-        },
-        "worst_case_scenarios": [
-            "What's the absolute worst that could happen?",
-            "How bad could this get before we notice?",
-            "What if our assumptions are completely wrong?",
-            "What if malicious actors target this?"
-        ],
-        "stress_test_questions": [
-            "What breaks first under pressure?",
-            "Where is there no redundancy?",
-            "What do we trust that we shouldn't?",
-            "What could cascade into catastrophic failure?"
-        ]
+    analysis_prompt = """You are a red team analyst. Your job is to BREAK this idea. Think like an adversary, a competitor, a malicious user, or just Murphy's Law.
+
+Attack from multiple angles:
+- How could users game/exploit this?
+- How could competitors undermine this?
+- What technical/operational failures could occur?
+- What edge cases break the model?
+- How could this be weaponized or misused?
+- What happens at 10x or 100x scale?
+
+Be creative and ruthless. Find the weaknesses.
+
+Return a JSON object with this structure:
+{
+    "idea_summary": "brief summary",
+    "attack_vectors": [
+        {
+            "attack_name": "descriptive name",
+            "category": "gaming/competition/technical/scaling/misuse",
+            "how_attack_works": "step by step how this exploits the idea",
+            "likelihood": "high/medium/low",
+            "impact": "catastrophic/major/moderate/minor",
+            "example_scenario": "concrete example of this attack"
+        }
+    ],
+    "critical_vulnerabilities": [
+        {
+            "vulnerability": "what's weak",
+            "why_its_critical": "why this matters",
+            "fix": "how to address"
+        }
+    ],
+    "what_breaks_at_scale": [
+        "thing that works now but fails at 10x/100x"
+    ],
+    "worst_case_scenario": {
+        "scenario": "the absolute worst thing that could happen",
+        "probability": "high/medium/low",
+        "how_to_prevent": "what would stop this"
+    },
+    "defensive_recommendations": [
+        {
+            "defense": "what to implement",
+            "addresses": "which attacks/vulnerabilities this covers",
+            "priority": "immediate/soon/eventually"
+        }
+    ],
+    "monitoring_needed": [
+        "signal to watch for that indicates attack/failure"
+    ]
+}"""
+
+    fallback = {
+        "attack_vectors": [{"attack_name": "Analysis unavailable", "how_attack_works": "LLM not configured"}],
+        "critical_vulnerabilities": [],
+        "worst_case_scenario": {"scenario": "Unable to analyze"},
+        "defensive_recommendations": []
     }
     
-    return json.dumps(analysis, indent=2)
+    return generate_contextual_analysis(
+        "red_team_analysis", idea, attack_surface, analysis_prompt, fallback
+    )
+
+
+# =============================================================================
+# RUN SERVER
+# =============================================================================
 
-# Run the server
 if __name__ == "__main__":
     mcp.run()