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

quantumflow/pipeline/temporal_memory.py

@@ -0,0 +1,577 @@
+"""
+Temporal Memory for LSTM-like State Storage.
+
+Provides:
+- Sequential state storage with temporal ordering
+- Cosine similarity-based pattern matching
+- Cross-run historical queries
+- Optional quantum compression
+
+Example:
+    memory = TemporalMemoryStore()
+
+    # Store states
+    memory.store(pipeline_id, run_id, seq=0, state_vector=[0.1, 0.2, 0.3])
+    memory.store(pipeline_id, run_id, seq=1, state_vector=[0.2, 0.3, 0.4])
+
+    # Find similar patterns
+    similar = memory.find_similar(query_vector=[0.15, 0.25, 0.35], top_k=5)
+
+    # Use LSTM-like memory
+    lstm = LSTMMemory(hidden_size=64)
+    lstm.update(state_vector)
+    context = lstm.get_context()
+"""
+
+import math
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+import uuid
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MemoryEntry:
+    """A single entry in temporal memory."""
+
+    id: str
+    pipeline_id: str
+    run_id: str
+    sequence_number: int
+    state_vector: List[float]
+    dimension: int
+    is_compressed: bool = False
+    compressed_vector: Optional[List[float]] = None
+    compression_n_qubits: Optional[int] = None
+    extra_data: Dict[str, Any] = field(default_factory=dict)
+    norm: Optional[float] = None
+    cluster_id: Optional[int] = None
+
+    def __post_init__(self):
+        """Compute norm if not provided."""
+        if self.norm is None:
+            self.norm = math.sqrt(sum(x * x for x in self.state_vector))
+
+
+class TemporalMemoryStore:
+    """
+    Sequential state storage for pattern matching.
+
+    Supports:
+    - Store/retrieve state vectors with temporal ordering
+    - Cosine similarity search
+    - Cross-run queries
+    - Optional quantum compression
+    """
+
+    def __init__(
+        self,
+        use_database: bool = True,
+        enable_compression: bool = False,
+        backend: str = "simulator",
+    ):
+        """
+        Initialize temporal memory store.
+
+        Args:
+            use_database: Whether to persist to database
+            enable_compression: Enable quantum compression
+            backend: Quantum backend for compression
+        """
+        self.use_database = use_database
+        self.enable_compression = enable_compression
+        self.backend = backend
+
+        # In-memory storage
+        self._entries: Dict[str, Dict[str, List[MemoryEntry]]] = {}  # pipeline_id -> run_id -> entries
+
+        # Quantum compressor (lazy loaded)
+        self._compressor = None
+
+    def _get_compressor(self):
+        """Get or create quantum compressor."""
+        if self._compressor is None and self.enable_compression:
+            try:
+                from quantumflow.core.quantum_compressor import QuantumCompressor
+                self._compressor = QuantumCompressor(backend=self.backend)
+            except ImportError:
+                logger.warning("QuantumCompressor not available")
+        return self._compressor
+
+    def store(
+        self,
+        pipeline_id: str,
+        run_id: str,
+        sequence_number: int,
+        state_vector: List[float],
+        metadata: Optional[Dict[str, Any]] = None,
+        compress: bool = False,
+    ) -> str:
+        """
+        Store a state vector in temporal memory.
+
+        Args:
+            pipeline_id: Pipeline identifier
+            run_id: Run identifier
+            sequence_number: Sequence position
+            state_vector: State vector to store
+            metadata: Optional metadata
+            compress: Whether to apply quantum compression
+
+        Returns:
+            Entry ID
+        """
+        entry_id = str(uuid.uuid4())
+
+        # Compute norm for similarity search
+        norm = math.sqrt(sum(x * x for x in state_vector)) if state_vector else 0
+
+        # Quantum compression
+        compressed_vector = None
+        compression_n_qubits = None
+
+        if compress and self.enable_compression:
+            compressor = self._get_compressor()
+            if compressor:
+                try:
+                    compressed = compressor.compress(state_vector)
+                    compressed_vector = (
+                        compressed.amplitudes.tolist()
+                        if hasattr(compressed.amplitudes, "tolist")
+                        else list(compressed.amplitudes)
+                    )
+                    compression_n_qubits = compressed.n_qubits
+                except Exception as e:
+                    logger.warning(f"Compression failed: {e}")
+
+        entry = MemoryEntry(
+            id=entry_id,
+            pipeline_id=pipeline_id,
+            run_id=run_id,
+            sequence_number=sequence_number,
+            state_vector=state_vector,
+            dimension=len(state_vector),
+            is_compressed=compressed_vector is not None,
+            compressed_vector=compressed_vector,
+            compression_n_qubits=compression_n_qubits,
+            extra_data=metadata or {},
+            norm=norm,
+        )
+
+        # Store in memory
+        if pipeline_id not in self._entries:
+            self._entries[pipeline_id] = {}
+        if run_id not in self._entries[pipeline_id]:
+            self._entries[pipeline_id][run_id] = []
+
+        self._entries[pipeline_id][run_id].append(entry)
+
+        # Sort by sequence number
+        self._entries[pipeline_id][run_id].sort(key=lambda e: e.sequence_number)
+
+        # Database persistence
+        if self.use_database:
+            self._save_to_database(entry)
+
+        return entry_id
+
+    def _save_to_database(self, entry: MemoryEntry):
+        """Save entry to database."""
+        try:
+            from db.database import get_session
+            from db.models import TemporalMemoryState
+
+            with get_session() as session:
+                db_entry = TemporalMemoryState(
+                    id=uuid.UUID(entry.id),
+                    pipeline_id=uuid.UUID(entry.pipeline_id),
+                    run_id=uuid.UUID(entry.run_id),
+                    sequence_number=entry.sequence_number,
+                    state_vector=entry.state_vector,
+                    state_dimension=entry.dimension,
+                    is_compressed=entry.is_compressed,
+                    compressed_vector=entry.compressed_vector,
+                    compression_n_qubits=entry.compression_n_qubits,
+                    extra_data=entry.extra_data,
+                    state_norm=entry.norm,
+                    cluster_id=entry.cluster_id,
+                )
+                session.add(db_entry)
+                session.commit()
+
+        except Exception as e:
+            logger.warning(f"Database save failed: {e}")
+
+    def get_sequence(
+        self,
+        pipeline_id: str,
+        run_id: str,
+        start: int = 0,
+        end: Optional[int] = None,
+    ) -> List[MemoryEntry]:
+        """
+        Get a sequence of states from a run.
+
+        Args:
+            pipeline_id: Pipeline identifier
+            run_id: Run identifier
+            start: Start sequence number
+            end: End sequence number (exclusive)
+
+        Returns:
+            List of memory entries
+        """
+        if pipeline_id not in self._entries:
+            return []
+        if run_id not in self._entries[pipeline_id]:
+            return []
+
+        entries = self._entries[pipeline_id][run_id]
+
+        # Filter by sequence range
+        filtered = [
+            e
+            for e in entries
+            if e.sequence_number >= start and (end is None or e.sequence_number < end)
+        ]
+
+        return filtered
+
+    def get_latest(self, pipeline_id: str, run_id: str, n: int = 1) -> List[MemoryEntry]:
+        """
+        Get the N most recent entries from a run.
+
+        Args:
+            pipeline_id: Pipeline identifier
+            run_id: Run identifier
+            n: Number of entries
+
+        Returns:
+            List of most recent entries
+        """
+        entries = self.get_sequence(pipeline_id, run_id)
+        return entries[-n:] if entries else []
+
+    def find_similar(
+        self,
+        query_vector: List[float],
+        pipeline_id: Optional[str] = None,
+        top_k: int = 5,
+        threshold: float = 0.0,
+    ) -> List[Tuple[MemoryEntry, float]]:
+        """
+        Find similar states using cosine similarity.
+
+        Args:
+            query_vector: Query state vector
+            pipeline_id: Optional filter by pipeline
+            top_k: Number of results to return
+            threshold: Minimum similarity threshold
+
+        Returns:
+            List of (entry, similarity) tuples
+        """
+        query_norm = math.sqrt(sum(x * x for x in query_vector))
+        if query_norm == 0:
+            return []
+
+        results: List[Tuple[MemoryEntry, float]] = []
+
+        # Iterate through all entries
+        pipelines = [pipeline_id] if pipeline_id else list(self._entries.keys())
+
+        for pid in pipelines:
+            if pid not in self._entries:
+                continue
+
+            for run_id, entries in self._entries[pid].items():
+                for entry in entries:
+                    # Skip if dimension mismatch
+                    if entry.dimension != len(query_vector):
+                        continue
+
+                    # Compute cosine similarity
+                    similarity = self._cosine_similarity(
+                        query_vector, entry.state_vector, query_norm, entry.norm
+                    )
+
+                    if similarity >= threshold:
+                        results.append((entry, similarity))
+
+        # Sort by similarity descending
+        results.sort(key=lambda x: x[1], reverse=True)
+
+        return results[:top_k]
+
+    def _cosine_similarity(
+        self,
+        vec1: List[float],
+        vec2: List[float],
+        norm1: Optional[float] = None,
+        norm2: Optional[float] = None,
+    ) -> float:
+        """Compute cosine similarity between two vectors."""
+        if len(vec1) != len(vec2):
+            return 0.0
+
+        dot_product = sum(a * b for a, b in zip(vec1, vec2))
+
+        if norm1 is None:
+            norm1 = math.sqrt(sum(x * x for x in vec1))
+        if norm2 is None:
+            norm2 = math.sqrt(sum(x * x for x in vec2))
+
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+
+        return dot_product / (norm1 * norm2)
+
+    def find_patterns(
+        self,
+        pattern: List[List[float]],
+        pipeline_id: Optional[str] = None,
+        similarity_threshold: float = 0.8,
+    ) -> List[Tuple[str, str, int, float]]:
+        """
+        Find sequences matching a pattern.
+
+        Args:
+            pattern: List of state vectors forming the pattern
+            pipeline_id: Optional filter by pipeline
+            similarity_threshold: Minimum average similarity
+
+        Returns:
+            List of (pipeline_id, run_id, start_seq, avg_similarity)
+        """
+        pattern_length = len(pattern)
+        if pattern_length == 0:
+            return []
+
+        results: List[Tuple[str, str, int, float]] = []
+
+        pipelines = [pipeline_id] if pipeline_id else list(self._entries.keys())
+
+        for pid in pipelines:
+            if pid not in self._entries:
+                continue
+
+            for run_id, entries in self._entries[pid].items():
+                if len(entries) < pattern_length:
+                    continue
+
+                # Slide window through sequence
+                for start in range(len(entries) - pattern_length + 1):
+                    window = entries[start : start + pattern_length]
+
+                    # Check dimension compatibility
+                    if any(
+                        e.dimension != len(p)
+                        for e, p in zip(window, pattern)
+                    ):
+                        continue
+
+                    # Compute average similarity
+                    similarities = [
+                        self._cosine_similarity(e.state_vector, p)
+                        for e, p in zip(window, pattern)
+                    ]
+                    avg_similarity = sum(similarities) / len(similarities)
+
+                    if avg_similarity >= similarity_threshold:
+                        results.append((pid, run_id, window[0].sequence_number, avg_similarity))
+
+        # Sort by similarity
+        results.sort(key=lambda x: x[3], reverse=True)
+
+        return results
+
+    def get_run_ids(self, pipeline_id: str) -> List[str]:
+        """Get all run IDs for a pipeline."""
+        if pipeline_id not in self._entries:
+            return []
+        return list(self._entries[pipeline_id].keys())
+
+    def clear_run(self, pipeline_id: str, run_id: str):
+        """Clear all entries for a run."""
+        if pipeline_id in self._entries and run_id in self._entries[pipeline_id]:
+            del self._entries[pipeline_id][run_id]
+
+    def clear_pipeline(self, pipeline_id: str):
+        """Clear all entries for a pipeline."""
+        if pipeline_id in self._entries:
+            del self._entries[pipeline_id]
+
+
+class LSTMMemory:
+    """
+    LSTM-like memory for sequential state processing.
+
+    Maintains:
+    - Hidden state (short-term memory)
+    - Cell state (long-term memory)
+    - Attention over recent states
+
+    Simplified LSTM without trainable parameters - uses
+    fixed transformations for state updates.
+    """
+
+    def __init__(
+        self,
+        hidden_size: int = 64,
+        memory_length: int = 20,
+        forget_rate: float = 0.1,
+    ):
+        """
+        Initialize LSTM memory.
+
+        Args:
+            hidden_size: Size of hidden/cell states
+            memory_length: Number of recent states to attend over
+            forget_rate: Rate of forgetting (0-1)
+        """
+        self.hidden_size = hidden_size
+        self.memory_length = memory_length
+        self.forget_rate = forget_rate
+
+        # States (initialized to zeros)
+        self.hidden_state: List[float] = [0.0] * hidden_size
+        self.cell_state: List[float] = [0.0] * hidden_size
+
+        # Recent states for attention
+        self.recent_states: List[List[float]] = []
+
+    def _sigmoid(self, x: float) -> float:
+        """Sigmoid activation."""
+        return 1.0 / (1.0 + math.exp(-max(-500, min(500, x))))
+
+    def _tanh(self, x: float) -> float:
+        """Tanh activation."""
+        return math.tanh(max(-500, min(500, x)))
+
+    def _project(self, input_vec: List[float], target_size: int) -> List[float]:
+        """Project input to target size (simple averaging/padding)."""
+        if len(input_vec) == target_size:
+            return input_vec
+
+        if len(input_vec) > target_size:
+            # Average pooling
+            ratio = len(input_vec) / target_size
+            result = []
+            for i in range(target_size):
+                start = int(i * ratio)
+                end = int((i + 1) * ratio)
+                result.append(sum(input_vec[start:end]) / (end - start))
+            return result
+        else:
+            # Pad with zeros
+            return input_vec + [0.0] * (target_size - len(input_vec))
+
+    def update(self, input_state: List[float]) -> List[float]:
+        """
+        Update memory with new input state.
+
+        Implements simplified LSTM update:
+        - forget_gate = sigmoid(input + hidden)
+        - input_gate = sigmoid(input + hidden)
+        - cell_candidate = tanh(input + hidden)
+        - cell_state = forget_gate * cell_state + input_gate * cell_candidate
+        - hidden_state = tanh(cell_state)
+
+        Args:
+            input_state: Input state vector
+
+        Returns:
+            Updated hidden state
+        """
+        # Project input to hidden size
+        projected = self._project(input_state, self.hidden_size)
+
+        # Compute gates (simplified - no learned weights)
+        forget_gate = []
+        input_gate = []
+        cell_candidate = []
+
+        for i in range(self.hidden_size):
+            combined = projected[i] + self.hidden_state[i]
+
+            # Forget gate (how much to forget)
+            f = self._sigmoid(combined - self.forget_rate)
+            forget_gate.append(f)
+
+            # Input gate (how much to update)
+            ig = self._sigmoid(combined)
+            input_gate.append(ig)
+
+            # Cell candidate
+            c = self._tanh(combined)
+            cell_candidate.append(c)
+
+        # Update cell state
+        for i in range(self.hidden_size):
+            self.cell_state[i] = (
+                forget_gate[i] * self.cell_state[i] +
+                input_gate[i] * cell_candidate[i]
+            )
+
+        # Update hidden state
+        self.hidden_state = [self._tanh(c) for c in self.cell_state]
+
+        # Store in recent states
+        self.recent_states.append(projected)
+        if len(self.recent_states) > self.memory_length:
+            self.recent_states.pop(0)
+
+        return self.hidden_state.copy()
+
+    def get_context(self) -> List[float]:
+        """
+        Get context vector with attention over recent states.
+
+        Returns:
+            Context vector combining hidden state and attended states
+        """
+        if not self.recent_states:
+            return self.hidden_state.copy()
+
+        # Compute attention scores (dot product with hidden state)
+        scores = []
+        for state in self.recent_states:
+            score = sum(h * s for h, s in zip(self.hidden_state, state))
+            scores.append(score)
+
+        # Softmax normalization
+        max_score = max(scores) if scores else 0
+        exp_scores = [math.exp(s - max_score) for s in scores]
+        sum_exp = sum(exp_scores) or 1
+
+        attention_weights = [e / sum_exp for e in exp_scores]
+
+        # Weighted sum of recent states
+        attended = [0.0] * self.hidden_size
+        for weight, state in zip(attention_weights, self.recent_states):
+            for i in range(self.hidden_size):
+                attended[i] += weight * state[i]
+
+        # Combine hidden state and attended context
+        context = [
+            0.5 * h + 0.5 * a
+            for h, a in zip(self.hidden_state, attended)
+        ]
+
+        return context
+
+    def reset(self):
+        """Reset memory states."""
+        self.hidden_state = [0.0] * self.hidden_size
+        self.cell_state = [0.0] * self.hidden_size
+        self.recent_states.clear()
+
+    def get_hidden_state(self) -> List[float]:
+        """Get current hidden state."""
+        return self.hidden_state.copy()
+
+    def get_cell_state(self) -> List[float]:
+        """Get current cell state."""
+        return self.cell_state.copy()

{quantumflow_sdk-0.3.0.dist-info → quantumflow_sdk-0.4.0.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: quantumflow-sdk
-Version: 0.3.0
-Summary: Quantum-optimized AI agent workflow platform with 53% token compression
+Version: 0.4.0
+Summary: Quantum-optimized AI agent workflow platform with 53% token compression, Gray-code measurement, and SES VQE
 Author-email: BlockQuantAI <hello@blockquant.ai>
 License-Expression: MIT
 Project-URL: Homepage, https://qflowai.dev
 Project-URL: Documentation, https://qflowai.dev/docs
 Project-URL: Repository, https://github.com/blockquantai/quantumflow
 Project-URL: Issues, https://github.com/blockquantai/quantumflow/issues
-Keywords: quantum,quantum-computing,ai,machine-learning,token-compression,qkd,teleportation,langchain,crewai
+Keywords: quantum,quantum-computing,ai,machine-learning,token-compression,qkd,teleportation,langchain,crewai,vqe,gray-code,ses-ansatz,tight-binding
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{quantumflow_sdk-0.3.0.dist-info → quantumflow_sdk-0.4.0.dist-info}/RECORD

@@ -1,15 +1,17 @@
 api/__init__.py,sha256=Oc_JXlNXQ8vZqr7A32xlhaW-FLUk2DfSVqjDoh4cv4Y,31
 api/auth.py,sha256=8gxgMSwsfsUCK0mM-ZTWM_ZsvTDvyOfVdO0NYLCHg1I,5942
-api/main.py,sha256=WQgi8h7FAjkwPlSiwGQhnviHZiAn7VZ79g_qeRUg-aQ,12673
-api/models.py,sha256=i0bwfN697wSxnIchHo13aOWkzZQE90WSRFUArJS0a2M,3262
+api/main.py,sha256=J6aBtKpBl3hj2jTxRmFrPZmeqJ03j09W0O_PnjswY18,13920
+api/models.py,sha256=GcG0XZ8x7ES73bqs2RsAUnvVYkEm7C-0uzdqMcjYOB8,4692
 api/routes/__init__.py,sha256=NsndLhwM3PzBnPYSUiKAu0pJKf2JnVkt3vFbaFkA6PA,26
-api/routes/algorithm_routes.py,sha256=jPwogmqbRiW3YHZCY_XuUZEVSI08zTHpBOz2zKac0iA,30139
+api/routes/algorithm_routes.py,sha256=9oZr0u2aqV0uRYun52thF1ZAfLZJ_uesQ7nNnKP0Lo8,34901
 api/routes/auth_routes.py,sha256=f80G08AfUh2XCUdziJbncNH8HT9GlOq3f9BpX9p_ans,5966
+api/routes/chat_routes.py,sha256=ITg1PZRnY7e85pIMrQ1C5SedYCLydPAXyPP0UGExIxA,18023
+api/routes/pipeline_routes.py,sha256=rg-nv9R2RNEAan1XKMoE5A5eAVv_lPB-Hd5xKeAbkLs,19442
 api/routes/teleport_routes.py,sha256=8G8-lAuB1H2qSom7Im7s1NiiHRy0HBPzlnJ-QAer3DI,12149
 db/__init__.py,sha256=CLyI_3_AP7wQATuxLV2yHPvYDNikJYmH5BMQ3Oez1xw,280
 db/crud.py,sha256=q_HpP0RzsI7Lz1EMhEWzaMxdxzGAdVTBD2LALqbGLGQ,8175
 db/database.py,sha256=Md_e3z1t6NzKCCVdS4gRo0Pf6LNZvRClIX4QU8F8InI,2078
-db/models.py,sha256=W-NLqT6kGtXTN3r4DqVPSPglt-_iFDBlqB6e3nzflrg,5975
+db/models.py,sha256=FBwNQ6kd95dxpjsd3-IofwFsL-bsjsJKjNtME1LvkGY,18927
 quantumflow/__init__.py,sha256=lUdk3uElyzBJe_VRjAjbehIULFDcbmvFePieaayWIwk,1731
 quantumflow/algorithms/__init__.py,sha256=waXASb2jnbAcjV-xS1wx-bGmPJ5lCj111dJ14eB8KCo,916
 quantumflow/algorithms/compression/__init__.py,sha256=rejDCdZJEy1tamQdDaZodGbo8wA1rszlXEtwvYgZO7A,361
@@ -19,10 +21,10 @@ quantumflow/algorithms/compression/token_compression.py,sha256=qwjV-fWV7fy9PvEQS
 quantumflow/algorithms/cryptography/__init__.py,sha256=uzJMUgBJIH16gP_RaZhg9Ue66uw8mwqUYMllfhOU9Bw,173
 quantumflow/algorithms/cryptography/qkd.py,sha256=mFRlypQXi4AhFxSy0FBpuAapJh5La1rx-siL1cJoqTc,6023
 quantumflow/algorithms/cryptography/qrng.py,sha256=aVyFZZZYsNw-LKZghIF505BQDzX9uc2kIrcoK92OXU8,5875
-quantumflow/algorithms/machine_learning/__init__.py,sha256=P2jSE7ibOaA9uzUw2Mu8p2zc-D5t9nwEsnSBmgQSJ5Y,252
+quantumflow/algorithms/machine_learning/__init__.py,sha256=OcDRTJIPUs86zxfnXhRMEQCFpAaibzoLrf1kBlr_h5o,408
 quantumflow/algorithms/machine_learning/qnn.py,sha256=1aPNNTu0I2c_C6maPKWDMHW2p-Torz6nhGrIeD8gCs0,7972
 quantumflow/algorithms/machine_learning/qsvm.py,sha256=_JAsrMI7nthOdmN8VETCXwpjCOaO1q-bQJQR-1eMPj8,7839
-quantumflow/algorithms/machine_learning/vqe.py,sha256=Vy5wxr2KAKBK_qphMn9seKckoVrqNbqKgsZr66SKNpU,6958
+quantumflow/algorithms/machine_learning/vqe.py,sha256=SP_LHFSnKM3f71KuXvqPy4QEdwoTZ8PNQDWHG3p2tDU,19067
 quantumflow/algorithms/optimization/__init__.py,sha256=gQ_EgS4je9HBwk563bY86kuTfqWwPMnFGV-HcxuLsr0,297
 quantumflow/algorithms/optimization/grover.py,sha256=onn6rgIZFIw9CAPQQDhnc_1Y8PkQJYF8-GNLFUZPg8Y,6250
 quantumflow/algorithms/optimization/qaoa.py,sha256=7VsD456_P4JrzsUJ9nJ2DEKOEoGLHdHUetqOfIwedFw,7254
@@ -42,23 +44,33 @@ quantumflow/backends/simulator_backend.py,sha256=tMbDcGwOWYbhTA8gNZheCfk1inAwbsH
 quantumflow/billing/__init__.py,sha256=4b9JwTXIT7LsehvkX42bsvMZ6RvcP3om5MuW9i9ulXo,484
 quantumflow/billing/models.py,sha256=NeLbWX_31T52gKTL_toYcSwjUjzk3Te9jq0QFPaMTbY,3344
 quantumflow/billing/stripe_service.py,sha256=Fy5vUSUQt2r3kKAQhb2KzxMAklOoB-bOnjZE0fAKbYg,20525
-quantumflow/core/__init__.py,sha256=fZFBkVu1wsLf7qSY1s3OMi6oBIwy65K_Cwk-jrd_SSo,359
+quantumflow/core/__init__.py,sha256=-oDYnG4iq8251BSueR3aFOK1xjNES8ZR-UIJ7IAFDHs,538
 quantumflow/core/entanglement.py,sha256=0H9XKU7D5OkUBgMEiNKsvfjAhsiD2TX3BmCYzrVyd5U,4663
 quantumflow/core/memory.py,sha256=0rB2Dks3XM1NEiL-v4G0P6jeL2BvcdJNljezRrVccdI,4494
 quantumflow/core/quantum_backprop.py,sha256=XozlPtwinegI5NosxlW4TrpP5Zh58_yI8WnxznwBHlU,12370
-quantumflow/core/quantum_compressor.py,sha256=okzfF4-1uL22FcK9Xhng1DLzmIbz3ADN-R1xzFTv-tI,10094
+quantumflow/core/quantum_compressor.py,sha256=iwEON8FocQk6CcMtLdPEJbKq8J70PpZ-7GyMpbFMSDQ,21973
 quantumflow/core/teleportation.py,sha256=_T5rRItjFramqWdqBNLwu_fY7Yr9pmdUda4L7STcwcA,12420
 quantumflow/core/workflow.py,sha256=HCazmlPns68TvIJytvcVoy0LSHb9sO-pUcDN5wPR2Zw,10116
 quantumflow/integrations/__init__.py,sha256=ksQr0HHYMwTBY0_MgyT5MUBX9fdRn_QErDzHs8rQ7F8,2979
 quantumflow/integrations/autogen_tools.py,sha256=sTTX7mGFjUKbmVatlcY9N9F2NeR6vkIj-VYduE0SNus,14672
 quantumflow/integrations/crewai_agents.py,sha256=t62hukL0xg2FV54yczTAakNYQA-AOZ9AWWgzDnH0LGM,12604
 quantumflow/integrations/crewai_tools.py,sha256=bY5uJyKmCegt6Kb9hvErhvaKcCDlk2_injx50-krN7E,13744
+quantumflow/integrations/domain_agents.py,sha256=-51HX4VPX9gfCw3egzduydpIEyMgdSXbRH1yZABAtQk,20545
 quantumflow/integrations/langchain_memory.py,sha256=wgYTdovncZNWpFwcNZjhNUqNRi661ys9GXaHYmbXP-Q,12608
 quantumflow/integrations/langchain_tools.py,sha256=bDrKZDYSRQJJGSNc9iay1Q4NoIR8CHmtZLcybS5ub_w,12401
 quantumflow/integrations/mcp_server.py,sha256=KJTAxJOyCVl7-whTD1iss9VZmyi0K1f4gNJCH8Cvl_0,21117
 quantumflow/integrations/openai_functions.py,sha256=8jQH4XkBxK9AbwC47BEYVIrbRAEWGdsMyw0xbZrGNB4,18412
-quantumflow_sdk-0.3.0.dist-info/METADATA,sha256=d-Zb7TDbvirOoWHjSPap2p2V6tHYZPhe0Zu5k7fIbGY,5461
-quantumflow_sdk-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-quantumflow_sdk-0.3.0.dist-info/entry_points.txt,sha256=ebX2acoOLgym42XZEqym3OfKCYiPz-mFuPSSGsHFz4c,53
-quantumflow_sdk-0.3.0.dist-info/top_level.txt,sha256=hEr_GRvoZ3-83naVIhNuJvoAND1aCvhBag_ynxQguIo,19
-quantumflow_sdk-0.3.0.dist-info/RECORD,,
+quantumflow/pipeline/__init__.py,sha256=OktP_tFPAoCREuAd7BmJbcSiGn7cmnsnqfbogsBrPEA,905
+quantumflow/pipeline/anomaly_detector.py,sha256=VR46CMdSeoTnZu7YsNIvB4Q2tAIMSP1_cb3nxYBRVfo,16576
+quantumflow/pipeline/base_pipeline.py,sha256=z5EhaUru-3UTBsBUcG08d6Oc3G48m5zxLnvDCU6Ji4I,18883
+quantumflow/pipeline/checkpoint_manager.py,sha256=XadGFl6a5KL4SbD76TG7xIheECTUgrMyaxrNH-3nLRA,20105
+quantumflow/pipeline/temporal_memory.py,sha256=SToIJQYec_5trS9jDd5j75_9SS-GKfgUWBjiw9rWj7Y,18391
+quantumflow/pipeline/finance/__init__.py,sha256=Y3CWyWCRVfhBKy40UX0T40Obez3k5xq3ZHDqy7tYbZU,172
+quantumflow/pipeline/finance/portfolio_optimization.py,sha256=D_Jt0Fu4BPQkhVxY_UF1nNZobTq-P19HGa7Y7g11JN4,20301
+quantumflow/pipeline/healthcare/__init__.py,sha256=cxhCICqhp3LUVOxfMNnvKmDUDiPLUG1Da7FdoID_xko,157
+quantumflow/pipeline/healthcare/protein_folding.py,sha256=nL2kEP55jaTs-jPuKSnyTFQAX4BlA4tjslr3PH0ogZI,34299
+quantumflow_sdk-0.4.0.dist-info/METADATA,sha256=a-tFVJXcJMSqm_Av_2mQhCwfPbvcBtk8YgbXdKFWvbc,5536
+quantumflow_sdk-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+quantumflow_sdk-0.4.0.dist-info/entry_points.txt,sha256=ebX2acoOLgym42XZEqym3OfKCYiPz-mFuPSSGsHFz4c,53
+quantumflow_sdk-0.4.0.dist-info/top_level.txt,sha256=hEr_GRvoZ3-83naVIhNuJvoAND1aCvhBag_ynxQguIo,19
+quantumflow_sdk-0.4.0.dist-info/RECORD,,