quantumflow-sdk 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

quantumflow/integrations/domain_agents.py

@@ -0,0 +1,617 @@
+"""
+Domain-Specific Quantum Agents for CrewAI.
+
+Provides specialized agents for:
+- Healthcare: Protein folding, drug discovery, mutation benchmarking
+- Finance: Portfolio optimization, risk analysis, regime detection
+
+Example:
+    from quantumflow.integrations.domain_agents import (
+        QuantumHealthcareAgent,
+        QuantumFinanceAgent,
+    )
+
+    # Create healthcare agent
+    health_agent = QuantumHealthcareAgent.create(llm=my_llm)
+    result = health_agent.execute(task)
+
+    # Create finance agent
+    finance_agent = QuantumFinanceAgent.create(llm=my_llm)
+    result = finance_agent.execute(task)
+"""
+
+import logging
+from typing import Any, Dict, List, Optional, Type
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+# Check for CrewAI availability
+try:
+    from crewai import Agent, Task, Crew
+    from crewai.tools import BaseTool
+    CREWAI_AVAILABLE = True
+except ImportError:
+    CREWAI_AVAILABLE = False
+    logger.warning("CrewAI not installed. Domain agents will be limited.")
+
+
+# ============================================================
+# Healthcare Tools
+# ============================================================
+
+if CREWAI_AVAILABLE:
+
+    class ProteinFoldingTool(BaseTool):
+        """Tool for protein folding simulation using VQE."""
+
+        name: str = "protein_folding"
+        description: str = """
+        Simulate protein folding using quantum VQE algorithm.
+        Input: JSON with 'sequence' (amino acid sequence) and optional 'steps' (default 50).
+        Returns: Folding results including final energy and RMSD.
+        """
+
+        def _run(self, input_data: str) -> str:
+            """Execute protein folding."""
+            import json
+
+            try:
+                data = json.loads(input_data) if isinstance(input_data, str) else input_data
+                sequence = data.get("sequence", "MVLSPAD")
+                steps = data.get("steps", 50)
+
+                from quantumflow.pipeline.healthcare.protein_folding import (
+                    ProteinFoldingPipeline,
+                )
+
+                pipeline = ProteinFoldingPipeline(
+                    name="Agent Protein Folding",
+                    sequence=sequence,
+                )
+
+                result = pipeline.run(total_steps=steps)
+
+                return json.dumps({
+                    "status": result.status,
+                    "final_energy": result.final_state.metrics.get("energy"),
+                    "final_rmsd": result.final_state.metrics.get("rmsd"),
+                    "steps_completed": result.total_steps,
+                    "anomalies_detected": result.anomalies_detected,
+                })
+
+            except Exception as e:
+                return json.dumps({"error": str(e)})
+
+
+    class MutationBenchmarkTool(BaseTool):
+        """Tool for benchmarking protein mutations."""
+
+        name: str = "mutation_benchmark"
+        description: str = """
+        Benchmark the effect of mutations on protein stability.
+        Input: JSON with 'original_sequence', 'mutated_sequence', and optional 'steps'.
+        Returns: Comparison of energy and stability metrics.
+        """
+
+        def _run(self, input_data: str) -> str:
+            """Execute mutation benchmark."""
+            import json
+
+            try:
+                data = json.loads(input_data) if isinstance(input_data, str) else input_data
+                original = data.get("original_sequence", "MVLSPAD")
+                mutated = data.get("mutated_sequence", "MVLSAAD")
+                steps = data.get("steps", 30)
+
+                from quantumflow.pipeline.healthcare.protein_folding import (
+                    ProteinFoldingPipeline,
+                )
+
+                # Run original
+                original_pipeline = ProteinFoldingPipeline(
+                    name="Original",
+                    sequence=original,
+                )
+                original_result = original_pipeline.run(total_steps=steps)
+
+                # Run mutated
+                mutated_pipeline = ProteinFoldingPipeline(
+                    name="Mutated",
+                    sequence=mutated,
+                )
+                mutated_result = mutated_pipeline.run(total_steps=steps)
+
+                original_energy = original_result.final_state.metrics.get("energy", 0)
+                mutated_energy = mutated_result.final_state.metrics.get("energy", 0)
+
+                return json.dumps({
+                    "original": {
+                        "sequence": original,
+                        "final_energy": original_energy,
+                        "rmsd": original_result.final_state.metrics.get("rmsd"),
+                    },
+                    "mutated": {
+                        "sequence": mutated,
+                        "final_energy": mutated_energy,
+                        "rmsd": mutated_result.final_state.metrics.get("rmsd"),
+                    },
+                    "energy_difference": mutated_energy - original_energy,
+                    "stability_impact": "destabilizing" if mutated_energy > original_energy else "stabilizing",
+                })
+
+            except Exception as e:
+                return json.dumps({"error": str(e)})
+
+
+    class DrugBindingTool(BaseTool):
+        """Tool for analyzing drug-protein binding."""
+
+        name: str = "drug_binding"
+        description: str = """
+        Analyze potential drug binding to a protein target.
+        Input: JSON with 'protein_sequence' and 'ligand_smiles'.
+        Returns: Binding affinity estimate and interaction analysis.
+        """
+
+        def _run(self, input_data: str) -> str:
+            """Execute drug binding analysis."""
+            import json
+            import random
+
+            try:
+                data = json.loads(input_data) if isinstance(input_data, str) else input_data
+                protein = data.get("protein_sequence", "MVLSPAD")
+                ligand = data.get("ligand_smiles", "CC(=O)O")
+
+                # Simplified binding analysis (would use quantum docking in production)
+                binding_energy = -random.uniform(5, 15)  # kcal/mol
+                binding_probability = random.uniform(0.3, 0.9)
+
+                return json.dumps({
+                    "protein_length": len(protein),
+                    "ligand": ligand,
+                    "estimated_binding_energy_kcal": round(binding_energy, 2),
+                    "binding_probability": round(binding_probability, 3),
+                    "interaction_type": "hydrogen_bond" if binding_energy < -10 else "van_der_waals",
+                    "recommendation": "promising" if binding_energy < -8 else "weak_binding",
+                })
+
+            except Exception as e:
+                return json.dumps({"error": str(e)})
+
+
+    # ============================================================
+    # Finance Tools
+    # ============================================================
+
+    class PortfolioOptimizationTool(BaseTool):
+        """Tool for QAOA-based portfolio optimization."""
+
+        name: str = "portfolio_optimization"
+        description: str = """
+        Optimize portfolio allocation using quantum QAOA algorithm.
+        Input: JSON with 'assets' (list), 'expected_returns' (list), and optional 'initial_capital', 'steps'.
+        Returns: Optimal weights and risk metrics.
+        """
+
+        def _run(self, input_data: str) -> str:
+            """Execute portfolio optimization."""
+            import json
+
+            try:
+                data = json.loads(input_data) if isinstance(input_data, str) else input_data
+                assets = data.get("assets", ["AAPL", "GOOGL", "MSFT"])
+                returns = data.get("expected_returns", [0.12, 0.10, 0.11])
+                capital = data.get("initial_capital", 100000)
+                steps = data.get("steps", 50)
+
+                from quantumflow.pipeline.finance.portfolio_optimization import (
+                    PortfolioOptimizationPipeline,
+                )
+
+                pipeline = PortfolioOptimizationPipeline(
+                    name="Agent Portfolio Optimization",
+                    assets=assets,
+                    expected_returns=returns,
+                    initial_capital=capital,
+                )
+
+                result = pipeline.run(total_steps=steps)
+
+                return json.dumps({
+                    "status": result.status,
+                    "optimal_weights": dict(zip(assets, result.final_state.weights)),
+                    "final_value": result.final_state.portfolio_value,
+                    "sharpe_ratio": result.final_state.metrics.get("sharpe_ratio"),
+                    "var": result.final_state.metrics.get("var"),
+                    "max_drawdown": result.final_state.metrics.get("max_drawdown"),
+                    "market_regime": result.final_state.market_regime,
+                })
+
+            except Exception as e:
+                return json.dumps({"error": str(e)})
+
+
+    class RiskAnalysisTool(BaseTool):
+        """Tool for portfolio risk analysis."""
+
+        name: str = "risk_analysis"
+        description: str = """
+        Analyze risk metrics for a given portfolio.
+        Input: JSON with 'weights' (dict of asset:weight), 'returns_history' (list of daily returns).
+        Returns: VaR, CVaR, Sharpe ratio, Sortino ratio, and risk classification.
+        """
+
+        def _run(self, input_data: str) -> str:
+            """Execute risk analysis."""
+            import json
+            import math
+
+            try:
+                data = json.loads(input_data) if isinstance(input_data, str) else input_data
+                weights = data.get("weights", {"AAPL": 0.5, "GOOGL": 0.5})
+                returns_history = data.get("returns_history", [0.01, -0.02, 0.015, -0.01, 0.02])
+
+                if not returns_history:
+                    return json.dumps({"error": "No returns history provided"})
+
+                # Calculate metrics
+                mean_return = sum(returns_history) / len(returns_history)
+                variance = sum((r - mean_return) ** 2 for r in returns_history) / len(returns_history)
+                std = math.sqrt(variance) if variance > 0 else 0.0001
+
+                # VaR (95%)
+                sorted_returns = sorted(returns_history)
+                var_idx = int(0.05 * len(sorted_returns))
+                var_95 = -sorted_returns[var_idx] if var_idx < len(sorted_returns) else 0
+
+                # CVaR
+                cvar = -sum(sorted_returns[:max(1, var_idx)]) / max(1, var_idx)
+
+                # Sharpe (assuming 2% risk-free rate)
+                rf_daily = 0.02 / 252
+                sharpe = (mean_return - rf_daily) / std if std > 0 else 0
+
+                # Risk classification
+                if var_95 > 0.05:
+                    risk_class = "high"
+                elif var_95 > 0.02:
+                    risk_class = "medium"
+                else:
+                    risk_class = "low"
+
+                return json.dumps({
+                    "mean_daily_return": round(mean_return, 6),
+                    "volatility": round(std, 6),
+                    "var_95": round(var_95, 6),
+                    "cvar_95": round(cvar, 6),
+                    "sharpe_ratio": round(sharpe, 4),
+                    "risk_classification": risk_class,
+                    "portfolio_weights": weights,
+                })
+
+            except Exception as e:
+                return json.dumps({"error": str(e)})
+
+
+    class RegimeDetectionTool(BaseTool):
+        """Tool for market regime detection."""
+
+        name: str = "regime_detection"
+        description: str = """
+        Detect current market regime from price/return data.
+        Input: JSON with 'returns_history' (list of recent daily returns).
+        Returns: Detected regime (bull/bear/sideways/crisis) and confidence.
+        """
+
+        def _run(self, input_data: str) -> str:
+            """Execute regime detection."""
+            import json
+            import math
+
+            try:
+                data = json.loads(input_data) if isinstance(input_data, str) else input_data
+                returns = data.get("returns_history", [])
+
+                if len(returns) < 5:
+                    return json.dumps({"error": "Need at least 5 returns for regime detection"})
+
+                # Calculate statistics
+                mean_return = sum(returns) / len(returns)
+                variance = sum((r - mean_return) ** 2 for r in returns) / len(returns)
+                volatility = math.sqrt(variance)
+
+                # Regime classification
+                if mean_return > 0.001 and volatility < 0.02:
+                    regime = "bull"
+                    confidence = min(0.9, 0.5 + mean_return * 10)
+                elif mean_return < -0.001 and volatility < 0.02:
+                    regime = "bear"
+                    confidence = min(0.9, 0.5 + abs(mean_return) * 10)
+                elif volatility > 0.03:
+                    regime = "crisis"
+                    confidence = min(0.95, 0.5 + volatility * 10)
+                else:
+                    regime = "sideways"
+                    confidence = 0.6
+
+                return json.dumps({
+                    "regime": regime,
+                    "confidence": round(confidence, 3),
+                    "mean_return": round(mean_return, 6),
+                    "volatility": round(volatility, 6),
+                    "recommendation": {
+                        "bull": "Consider increasing equity exposure",
+                        "bear": "Consider defensive positions or hedging",
+                        "sideways": "Maintain current allocation",
+                        "crisis": "Reduce risk exposure, increase cash",
+                    }[regime],
+                })
+
+            except Exception as e:
+                return json.dumps({"error": str(e)})
+
+
+# ============================================================
+# Agent Classes
+# ============================================================
+
+@dataclass
+class AgentConfig:
+    """Configuration for domain agents."""
+
+    verbose: bool = True
+    allow_delegation: bool = False
+    max_iterations: int = 10
+    backend: str = "simulator"
+
+
+class QuantumHealthcareAgent:
+    """
+    Quantum-powered healthcare agent for CrewAI.
+
+    Specializes in:
+    - Protein folding simulations
+    - Mutation effect analysis
+    - Drug binding predictions
+    """
+
+    ROLE = "Quantum Healthcare Researcher"
+    GOAL = "Analyze proteins and molecular structures using quantum computing"
+    BACKSTORY = """You are a quantum computing specialist focused on healthcare
+    and drug discovery applications. You use VQE-based protein folding simulations
+    to analyze molecular structures and predict drug interactions."""
+
+    @classmethod
+    def get_tools(cls) -> List[Any]:
+        """Get healthcare-specific tools."""
+        if not CREWAI_AVAILABLE:
+            return []
+
+        return [
+            ProteinFoldingTool(),
+            MutationBenchmarkTool(),
+            DrugBindingTool(),
+        ]
+
+    @classmethod
+    def create(
+        cls,
+        llm: Any,
+        config: Optional[AgentConfig] = None,
+    ) -> Optional["Agent"]:
+        """
+        Create a healthcare agent.
+
+        Args:
+            llm: Language model for the agent
+            config: Agent configuration
+
+        Returns:
+            CrewAI Agent or None if unavailable
+        """
+        if not CREWAI_AVAILABLE:
+            logger.warning("CrewAI not available, cannot create agent")
+            return None
+
+        config = config or AgentConfig()
+
+        return Agent(
+            role=cls.ROLE,
+            goal=cls.GOAL,
+            backstory=cls.BACKSTORY,
+            llm=llm,
+            tools=cls.get_tools(),
+            verbose=config.verbose,
+            allow_delegation=config.allow_delegation,
+            max_iter=config.max_iterations,
+        )
+
+
+class QuantumFinanceAgent:
+    """
+    Quantum-powered finance agent for CrewAI.
+
+    Specializes in:
+    - Portfolio optimization (QAOA)
+    - Risk analysis (VaR, CVaR)
+    - Market regime detection
+    """
+
+    ROLE = "Quantum Finance Analyst"
+    GOAL = "Optimize portfolios and analyze financial risk using quantum computing"
+    BACKSTORY = """You are a quantitative finance expert who leverages quantum
+    algorithms for portfolio optimization and risk management. You use QAOA
+    for portfolio construction and quantum-enhanced risk metrics."""
+
+    @classmethod
+    def get_tools(cls) -> List[Any]:
+        """Get finance-specific tools."""
+        if not CREWAI_AVAILABLE:
+            return []
+
+        return [
+            PortfolioOptimizationTool(),
+            RiskAnalysisTool(),
+            RegimeDetectionTool(),
+        ]
+
+    @classmethod
+    def create(
+        cls,
+        llm: Any,
+        config: Optional[AgentConfig] = None,
+    ) -> Optional["Agent"]:
+        """
+        Create a finance agent.
+
+        Args:
+            llm: Language model for the agent
+            config: Agent configuration
+
+        Returns:
+            CrewAI Agent or None if unavailable
+        """
+        if not CREWAI_AVAILABLE:
+            logger.warning("CrewAI not available, cannot create agent")
+            return None
+
+        config = config or AgentConfig()
+
+        return Agent(
+            role=cls.ROLE,
+            goal=cls.GOAL,
+            backstory=cls.BACKSTORY,
+            llm=llm,
+            tools=cls.get_tools(),
+            verbose=config.verbose,
+            allow_delegation=config.allow_delegation,
+            max_iter=config.max_iterations,
+        )
+
+
+# ============================================================
+# Crew Factory
+# ============================================================
+
+def create_healthcare_crew(
+    llm: Any,
+    tasks: List[Dict[str, str]],
+    verbose: bool = True,
+) -> Optional["Crew"]:
+    """
+    Create a healthcare-focused crew.
+
+    Args:
+        llm: Language model for agents
+        tasks: List of task definitions with 'description' and 'expected_output'
+        verbose: Enable verbose output
+
+    Returns:
+        CrewAI Crew or None if unavailable
+    """
+    if not CREWAI_AVAILABLE:
+        return None
+
+    agent = QuantumHealthcareAgent.create(llm)
+    if not agent:
+        return None
+
+    crew_tasks = [
+        Task(
+            description=t["description"],
+            expected_output=t.get("expected_output", "Analysis results"),
+            agent=agent,
+        )
+        for t in tasks
+    ]
+
+    return Crew(
+        agents=[agent],
+        tasks=crew_tasks,
+        verbose=verbose,
+    )
+
+
+def create_finance_crew(
+    llm: Any,
+    tasks: List[Dict[str, str]],
+    verbose: bool = True,
+) -> Optional["Crew"]:
+    """
+    Create a finance-focused crew.
+
+    Args:
+        llm: Language model for agents
+        tasks: List of task definitions with 'description' and 'expected_output'
+        verbose: Enable verbose output
+
+    Returns:
+        CrewAI Crew or None if unavailable
+    """
+    if not CREWAI_AVAILABLE:
+        return None
+
+    agent = QuantumFinanceAgent.create(llm)
+    if not agent:
+        return None
+
+    crew_tasks = [
+        Task(
+            description=t["description"],
+            expected_output=t.get("expected_output", "Analysis results"),
+            agent=agent,
+        )
+        for t in tasks
+    ]
+
+    return Crew(
+        agents=[agent],
+        tasks=crew_tasks,
+        verbose=verbose,
+    )
+
+
+def create_quantum_research_crew(
+    llm: Any,
+    tasks: List[Dict[str, str]],
+    verbose: bool = True,
+) -> Optional["Crew"]:
+    """
+    Create a multi-domain quantum research crew with both healthcare and finance agents.
+
+    Args:
+        llm: Language model for agents
+        tasks: List of task definitions
+        verbose: Enable verbose output
+
+    Returns:
+        CrewAI Crew or None if unavailable
+    """
+    if not CREWAI_AVAILABLE:
+        return None
+
+    health_agent = QuantumHealthcareAgent.create(llm)
+    finance_agent = QuantumFinanceAgent.create(llm)
+
+    if not health_agent or not finance_agent:
+        return None
+
+    agents = [health_agent, finance_agent]
+
+    crew_tasks = [
+        Task(
+            description=t["description"],
+            expected_output=t.get("expected_output", "Analysis results"),
+            agent=health_agent if "protein" in t["description"].lower() or "drug" in t["description"].lower()
+            else finance_agent,
+        )
+        for t in tasks
+    ]
+
+    return Crew(
+        agents=agents,
+        tasks=crew_tasks,
+        verbose=verbose,
+    )

quantumflow/pipeline/__init__.py

@@ -0,0 +1,29 @@
+"""
+QuantumFlow Data Pipeline System.
+
+Provides intelligent data pipelines with:
+- Checkpointing for long-running operations
+- Anomaly detection (gradient explosion, NaN, domain-specific)
+- LSTM-like temporal memory for pattern matching
+- Auto-rollback on critical failures
+
+Domain-specific pipelines:
+- Healthcare: Protein folding with VQE
+- Finance: Portfolio optimization with QAOA
+"""
+
+from quantumflow.pipeline.base_pipeline import BasePipeline, PipelineConfig, PipelineState
+from quantumflow.pipeline.checkpoint_manager import CheckpointManager
+from quantumflow.pipeline.anomaly_detector import AnomalyDetector, AnomalyResult
+from quantumflow.pipeline.temporal_memory import TemporalMemoryStore, LSTMMemory
+
+__all__ = [
+    "BasePipeline",
+    "PipelineConfig",
+    "PipelineState",
+    "CheckpointManager",
+    "AnomalyDetector",
+    "AnomalyResult",
+    "TemporalMemoryStore",
+    "LSTMMemory",
+]