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

quantumflow/__init__.py

@@ -6,10 +6,11 @@ Core Features:
 - O(log n) memory through quantum entanglement
 - Quantum teleportation for secure messaging
 - BB84 QKD for unconditionally secure key exchange
+- Workflow orchestration for chaining quantum operations
 - Multi-backend support (IBM, AWS Braket, Simulator)
 
 Installation:
-    pip install quantumflow
+    pip install quantumflow-sdk
 
 Quick Start:
     from quantumflow import QuantumCompressor
@@ -17,6 +18,14 @@ Quick Start:
     compressor = QuantumCompressor(backend="simulator")
     result = compressor.compress([100, 200, 150, 175])
     print(f"Compression: {result.compression_percentage}%")
+
+Workflow Example:
+    from quantumflow import QuantumWorkflow
+
+    workflow = QuantumWorkflow()
+    workflow.add_step("compress", params={"tokens": [100, 200, 150]})
+    workflow.add_step("qkd", params={"key_length": 256})
+    result = workflow.execute()
 """
 
 from quantumflow.core.quantum_compressor import QuantumCompressor, CompressedResult
@@ -28,8 +37,9 @@ from quantumflow.core.teleportation import (
     QKDExchange,
     SecureMessenger,
 )
+from quantumflow.core.workflow import QuantumWorkflow, WorkflowResult
 
-__version__ = "0.1.0"
+__version__ = "0.2.1"
 __all__ = [
     # Core compression
     "QuantumCompressor",
@@ -44,4 +54,7 @@ __all__ = [
     "QuantumTeleporter",
     "QKDExchange",
     "SecureMessenger",
+    # Workflow
+    "QuantumWorkflow",
+    "WorkflowResult",
 ]

quantumflow/api/routes/__init__.py

@@ -1,4 +1,5 @@
 # QuantumFlow API routes
 from quantumflow.api.routes.billing_routes import router as billing_router
+from quantumflow.api.routes.workflow_routes import router as workflow_router
 
-__all__ = ["billing_router"]
+__all__ = ["billing_router", "workflow_router"]

quantumflow/api/routes/workflow_routes.py

@@ -0,0 +1,227 @@
+"""
+Workflow API Routes.
+
+Provides REST API endpoints for quantum workflow orchestration.
+"""
+
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class WorkflowStepRequest:
+    """Request model for a workflow step."""
+    type: str
+    params: Optional[Dict[str, Any]] = None
+    depends_on: Optional[List[str]] = None
+    id: Optional[str] = None
+
+
+@dataclass
+class WorkflowRequest:
+    """Request model for creating a workflow."""
+    steps: List[Dict[str, Any]]
+    backend: str = "simulator"
+
+
+@dataclass
+class WorkflowResponse:
+    """Response model for workflow execution."""
+    workflow_id: str
+    status: str
+    steps: List[Dict[str, Any]]
+    total_duration_ms: float
+    outputs: Dict[str, Any]
+    error: Optional[str] = None
+
+
+def create_workflow_routes():
+    """
+    Create workflow API routes.
+
+    Returns a router that can be mounted on a FastAPI app.
+
+    Example usage with FastAPI:
+        from fastapi import FastAPI
+        from quantumflow.api.routes.workflow_routes import create_workflow_routes
+
+        app = FastAPI()
+        workflow_router = create_workflow_routes()
+        app.include_router(workflow_router, prefix="/v1/workflow")
+    """
+    try:
+        from fastapi import APIRouter, HTTPException
+        from pydantic import BaseModel
+    except ImportError:
+        # Return a dummy router if FastAPI is not installed
+        return None
+
+    router = APIRouter(tags=["workflow"])
+
+    class WorkflowStepModel(BaseModel):
+        type: str
+        params: Optional[Dict[str, Any]] = None
+        depends_on: Optional[List[str]] = None
+        id: Optional[str] = None
+
+    class CreateWorkflowModel(BaseModel):
+        steps: List[WorkflowStepModel]
+        backend: str = "simulator"
+
+    class ExecuteWorkflowModel(BaseModel):
+        workflow_id: Optional[str] = None
+        steps: Optional[List[WorkflowStepModel]] = None
+        backend: str = "simulator"
+
+    @router.post("/create")
+    async def create_workflow(request: CreateWorkflowModel) -> Dict[str, Any]:
+        """
+        Create a new workflow without executing it.
+
+        Returns the workflow definition that can be executed later.
+        """
+        from quantumflow.core.workflow import QuantumWorkflow
+
+        workflow = QuantumWorkflow(backend=request.backend)
+
+        for step in request.steps:
+            workflow.add_step(
+                step_type=step.type,
+                params=step.params,
+                depends_on=step.depends_on,
+                step_id=step.id,
+            )
+
+        return workflow.to_dict()
+
+    @router.post("/execute")
+    async def execute_workflow(request: ExecuteWorkflowModel) -> Dict[str, Any]:
+        """
+        Execute a quantum workflow.
+
+        Can either:
+        - Execute a new workflow by providing steps
+        - Execute an existing workflow by providing workflow_id
+
+        Returns execution results for all steps.
+        """
+        from quantumflow.core.workflow import QuantumWorkflow
+
+        if not request.steps:
+            raise HTTPException(
+                status_code=400,
+                detail="Steps are required to execute a workflow"
+            )
+
+        workflow = QuantumWorkflow(backend=request.backend)
+
+        for step in request.steps:
+            workflow.add_step(
+                step_type=step.type,
+                params=step.params,
+                depends_on=step.depends_on,
+                step_id=step.id,
+            )
+
+        result = workflow.execute()
+
+        return {
+            "workflow_id": result.workflow_id,
+            "status": result.status,
+            "steps": result.steps,
+            "total_duration_ms": result.total_duration_ms,
+            "outputs": result.outputs,
+            "error": result.error,
+        }
+
+    @router.post("/compress-and-teleport")
+    async def compress_and_teleport(
+        tokens: List[int],
+        recipient: Optional[str] = None,
+        backend: str = "simulator",
+    ) -> Dict[str, Any]:
+        """
+        Convenience endpoint that combines compression and teleportation.
+
+        This is a common workflow pattern for secure quantum messaging.
+        """
+        from quantumflow.core.workflow import QuantumWorkflow
+
+        workflow = QuantumWorkflow(backend=backend)
+
+        # Step 1: Compress tokens
+        workflow.add_step(
+            step_type="compress",
+            params={"tokens": tokens},
+            step_id="compression",
+        )
+
+        # Step 2: QKD key exchange
+        workflow.add_step(
+            step_type="qkd",
+            params={"key_length": 256},
+            step_id="key_exchange",
+            depends_on=["compression"],
+        )
+
+        # Step 3: Create Bell pairs for teleportation
+        workflow.add_step(
+            step_type="teleport",
+            params={"n_pairs": 10},
+            step_id="teleportation",
+            depends_on=["key_exchange"],
+        )
+
+        result = workflow.execute()
+
+        return {
+            "workflow_id": result.workflow_id,
+            "status": result.status,
+            "compression": result.outputs.get("compression", {}),
+            "qkd": result.outputs.get("key_exchange", {}),
+            "teleportation": result.outputs.get("teleportation", {}),
+            "total_duration_ms": result.total_duration_ms,
+        }
+
+    @router.get("/templates")
+    async def get_workflow_templates() -> List[Dict[str, Any]]:
+        """
+        Get available workflow templates.
+
+        Returns predefined workflow configurations for common use cases.
+        """
+        return [
+            {
+                "name": "secure_messaging",
+                "description": "Compress tokens, exchange QKD key, and teleport",
+                "steps": [
+                    {"type": "compress", "params": {"tokens": []}, "id": "compress"},
+                    {"type": "qkd", "params": {"key_length": 256}, "id": "qkd", "depends_on": ["compress"]},
+                    {"type": "teleport", "params": {"n_pairs": 10}, "id": "teleport", "depends_on": ["qkd"]},
+                ],
+            },
+            {
+                "name": "quantum_ml_training",
+                "description": "Quantum backpropagation workflow",
+                "steps": [
+                    {"type": "compress", "params": {"tokens": []}, "id": "compress_input"},
+                    {"type": "backprop", "params": {}, "id": "gradient", "depends_on": ["compress_input"]},
+                ],
+            },
+            {
+                "name": "optimization",
+                "description": "QAOA optimization workflow",
+                "steps": [
+                    {"type": "qaoa", "params": {"p": 2}, "id": "optimize"},
+                ],
+            },
+        ]
+
+    return router
+
+
+# Export router for use with FastAPI
+try:
+    router = create_workflow_routes()
+except Exception:
+    router = None

quantumflow/core/workflow.py

@@ -0,0 +1,311 @@
+"""
+Quantum Workflow Orchestration Module.
+
+Provides workflow orchestration for chaining quantum operations like:
+- Token compression
+- QKD key exchange
+- Quantum teleportation
+- Algorithm execution
+
+Example:
+    from quantumflow.core.workflow import QuantumWorkflow
+
+    workflow = QuantumWorkflow()
+    workflow.add_step("compress", tokens=[100, 200, 150])
+    workflow.add_step("qkd", key_length=256)
+    workflow.add_step("teleport", use_compression=True)
+    result = workflow.execute()
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+from enum import Enum
+import time
+import uuid
+
+
+class StepType(Enum):
+    """Types of workflow steps."""
+    COMPRESS = "compress"
+    DECOMPRESS = "decompress"
+    QKD = "qkd"
+    TELEPORT = "teleport"
+    BACKPROP = "backprop"
+    QAOA = "qaoa"
+    VQE = "vqe"
+    CUSTOM = "custom"
+
+
+class StepStatus(Enum):
+    """Status of a workflow step."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class WorkflowStep:
+    """A single step in a quantum workflow."""
+    id: str
+    step_type: StepType
+    params: Dict[str, Any]
+    status: StepStatus = StepStatus.PENDING
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    started_at: Optional[float] = None
+    completed_at: Optional[float] = None
+    depends_on: List[str] = field(default_factory=list)
+
+    @property
+    def duration_ms(self) -> Optional[float]:
+        """Duration of step execution in milliseconds."""
+        if self.started_at and self.completed_at:
+            return (self.completed_at - self.started_at) * 1000
+        return None
+
+
+@dataclass
+class WorkflowResult:
+    """Result of workflow execution."""
+    workflow_id: str
+    status: str
+    steps: List[Dict[str, Any]]
+    total_duration_ms: float
+    outputs: Dict[str, Any]
+    error: Optional[str] = None
+
+
+class QuantumWorkflow:
+    """
+    Orchestrates quantum operations in a workflow.
+
+    Supports:
+    - Sequential step execution
+    - Dependency management between steps
+    - Error handling and recovery
+    - Step result passing to subsequent steps
+    """
+
+    def __init__(self, backend: str = "simulator"):
+        """
+        Initialize a quantum workflow.
+
+        Args:
+            backend: Quantum backend to use (simulator, ibm, braket)
+        """
+        self.workflow_id = str(uuid.uuid4())
+        self.backend = backend
+        self.steps: List[WorkflowStep] = []
+        self._step_results: Dict[str, Any] = {}
+
+    def add_step(
+        self,
+        step_type: str,
+        params: Optional[Dict[str, Any]] = None,
+        depends_on: Optional[List[str]] = None,
+        step_id: Optional[str] = None,
+    ) -> str:
+        """
+        Add a step to the workflow.
+
+        Args:
+            step_type: Type of step (compress, qkd, teleport, etc.)
+            params: Parameters for the step
+            depends_on: List of step IDs this step depends on
+            step_id: Optional custom step ID
+
+        Returns:
+            The ID of the created step
+        """
+        if step_id is None:
+            step_id = f"step_{len(self.steps) + 1}"
+
+        step = WorkflowStep(
+            id=step_id,
+            step_type=StepType(step_type),
+            params=params or {},
+            depends_on=depends_on or [],
+        )
+        self.steps.append(step)
+        return step_id
+
+    def _execute_step(self, step: WorkflowStep) -> Dict[str, Any]:
+        """
+        Execute a single workflow step.
+
+        Args:
+            step: The step to execute
+
+        Returns:
+            Result of the step execution
+        """
+        from quantumflow.core.quantum_compressor import QuantumCompressor
+        from quantumflow.core.teleportation import QKDExchange, QuantumTeleporter
+
+        step.status = StepStatus.RUNNING
+        step.started_at = time.time()
+
+        try:
+            result = {}
+
+            if step.step_type == StepType.COMPRESS:
+                compressor = QuantumCompressor(backend=self.backend)
+                tokens = step.params.get("tokens", [])
+                compressed = compressor.compress(tokens)
+                result = {
+                    "amplitudes": compressed.amplitudes.tolist() if hasattr(compressed.amplitudes, 'tolist') else compressed.amplitudes,
+                    "n_qubits": compressed.n_qubits,
+                    "compression_percentage": compressed.compression_percentage,
+                    "input_token_count": compressed.input_token_count,
+                }
+
+            elif step.step_type == StepType.QKD:
+                qkd = QKDExchange(backend=self.backend)
+                key_length = step.params.get("key_length", 256)
+                qkd_result = qkd.exchange(key_length=key_length)
+                result = qkd_result
+
+            elif step.step_type == StepType.TELEPORT:
+                teleporter = QuantumTeleporter(backend=self.backend)
+                state = step.params.get("state")
+                if state:
+                    teleport_result = teleporter.teleport_state(state)
+                    result = {
+                        "fidelity": teleport_result.fidelity,
+                        "corrections_applied": teleport_result.corrections_applied,
+                    }
+                else:
+                    # Create Bell pairs
+                    n_pairs = step.params.get("n_pairs", 10)
+                    pairs = teleporter.create_bell_pairs(n_pairs)
+                    result = {"bell_pairs_created": n_pairs}
+
+            elif step.step_type == StepType.BACKPROP:
+                from quantumflow.core.quantum_backprop import QuantumBackprop
+                backprop = QuantumBackprop(backend=self.backend)
+                bp_result = backprop.compute_gradient(
+                    input_state=step.params.get("input_state", [0.5, 0.5]),
+                    target_state=step.params.get("target_state", [0.8, 0.2]),
+                    weights=step.params.get("weights", [0.3, 0.7]),
+                )
+                result = {
+                    "gradients": bp_result.gradients,
+                    "similarity": bp_result.similarity,
+                }
+
+            elif step.step_type == StepType.QAOA:
+                from quantumflow.algorithms.optimization.qaoa import QuantumQAOA
+                qaoa = QuantumQAOA(backend=self.backend)
+                qaoa_result = qaoa.optimize(
+                    problem=step.params.get("problem", {}),
+                    p=step.params.get("p", 2),
+                )
+                result = qaoa_result
+
+            elif step.step_type == StepType.VQE:
+                from quantumflow.algorithms.machine_learning.vqe import QuantumVQE
+                vqe = QuantumVQE(backend=self.backend)
+                vqe_result = vqe.find_ground_state(
+                    hamiltonian=step.params.get("hamiltonian", {}),
+                )
+                result = vqe_result
+
+            else:
+                # Custom step - just pass through params
+                result = step.params
+
+            step.status = StepStatus.COMPLETED
+            step.result = result
+            step.completed_at = time.time()
+
+            return result
+
+        except Exception as e:
+            step.status = StepStatus.FAILED
+            step.error = str(e)
+            step.completed_at = time.time()
+            raise
+
+    def execute(self) -> WorkflowResult:
+        """
+        Execute all steps in the workflow.
+
+        Returns:
+            WorkflowResult with all step results
+        """
+        start_time = time.time()
+        outputs = {}
+        error = None
+
+        try:
+            for step in self.steps:
+                # Check dependencies
+                for dep_id in step.depends_on:
+                    dep_step = next((s for s in self.steps if s.id == dep_id), None)
+                    if dep_step and dep_step.status != StepStatus.COMPLETED:
+                        step.status = StepStatus.SKIPPED
+                        step.error = f"Dependency {dep_id} not completed"
+                        continue
+
+                # Execute the step
+                result = self._execute_step(step)
+                self._step_results[step.id] = result
+                outputs[step.id] = result
+
+        except Exception as e:
+            error = str(e)
+
+        end_time = time.time()
+
+        return WorkflowResult(
+            workflow_id=self.workflow_id,
+            status="completed" if error is None else "failed",
+            steps=[
+                {
+                    "id": s.id,
+                    "type": s.step_type.value,
+                    "status": s.status.value,
+                    "result": s.result,
+                    "error": s.error,
+                    "duration_ms": s.duration_ms,
+                }
+                for s in self.steps
+            ],
+            total_duration_ms=(end_time - start_time) * 1000,
+            outputs=outputs,
+            error=error,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert workflow to dictionary representation."""
+        return {
+            "workflow_id": self.workflow_id,
+            "backend": self.backend,
+            "steps": [
+                {
+                    "id": s.id,
+                    "type": s.step_type.value,
+                    "params": s.params,
+                    "depends_on": s.depends_on,
+                }
+                for s in self.steps
+            ],
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "QuantumWorkflow":
+        """Create workflow from dictionary representation."""
+        workflow = cls(backend=data.get("backend", "simulator"))
+        workflow.workflow_id = data.get("workflow_id", workflow.workflow_id)
+
+        for step_data in data.get("steps", []):
+            workflow.add_step(
+                step_type=step_data["type"],
+                params=step_data.get("params", {}),
+                depends_on=step_data.get("depends_on", []),
+                step_id=step_data.get("id"),
+            )
+
+        return workflow

quantumflow/integrations/__init__.py

@@ -2,12 +2,21 @@
 QuantumFlow Integrations.
 
 Provides integration with popular AI agent frameworks:
+- OpenAI: Function calling for GPT-4/GPT-3.5-turbo
 - LangChain: Tools, Memory, and Chains
 - CrewAI: Tools and Agents
 - AutoGen: Agents and Function Tools
 - MCP: Model Context Protocol Server
 """
 
+# OpenAI Integration
+from quantumflow.integrations.openai_functions import (
+    get_quantum_functions as get_openai_functions,
+    get_quantum_tools as get_openai_tools,
+    execute_quantum_function,
+    QuantumAssistant,
+)
+
 # LangChain Integration
 from quantumflow.integrations.langchain_tools import (
     QuantumCompressTool,
@@ -64,6 +73,11 @@ from quantumflow.integrations.mcp_server import (
 )
 
 __all__ = [
+    # OpenAI Functions
+    "get_openai_functions",
+    "get_openai_tools",
+    "execute_quantum_function",
+    "QuantumAssistant",
     # LangChain Tools
     "QuantumCompressTool",
     "QuantumGradientTool",

quantumflow/integrations/openai_functions.py

@@ -0,0 +1,578 @@
+"""
+OpenAI Function Calling Integration for QuantumFlow.
+
+Provides function definitions and execution handlers compatible with
+OpenAI's function calling API (GPT-4, GPT-3.5-turbo).
+
+Usage:
+    from openai import OpenAI
+    from quantumflow.integrations.openai_functions import (
+        get_quantum_functions,
+        execute_quantum_function,
+    )
+
+    client = OpenAI()
+    functions = get_quantum_functions()
+
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Compress these tokens: 100, 200, 150"}],
+        functions=functions,
+        function_call="auto",
+    )
+
+    # Execute the function call
+    if response.choices[0].message.function_call:
+        result = execute_quantum_function(
+            response.choices[0].message.function_call.name,
+            json.loads(response.choices[0].message.function_call.arguments)
+        )
+"""
+
+import json
+from typing import Any, Dict, List, Optional, Callable
+from dataclasses import dataclass
+
+from quantumflow.core.quantum_compressor import QuantumCompressor
+from quantumflow.core.quantum_backprop import QuantumBackprop
+from quantumflow.core.teleportation import QuantumTeleporter, QKDExchange, SecureMessenger
+from quantumflow.core.entanglement import Entangler
+from quantumflow.core.memory import QuantumMemory
+
+
+# OpenAI Function Definitions
+QUANTUM_FUNCTIONS: List[Dict[str, Any]] = [
+    {
+        "name": "quantum_compress",
+        "description": "Compress a list of token values using quantum amplitude encoding. Achieves ~53% compression while preserving semantic information.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "tokens": {
+                    "type": "array",
+                    "items": {"type": "number"},
+                    "description": "List of token values (integers or floats) to compress",
+                },
+                "backend": {
+                    "type": "string",
+                    "enum": ["simulator", "ibm", "aws"],
+                    "description": "Quantum backend to use. Default: simulator",
+                },
+            },
+            "required": ["tokens"],
+        },
+    },
+    {
+        "name": "quantum_decompress",
+        "description": "Decompress previously quantum-compressed data back to original tokens.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "compressed_state": {
+                    "type": "array",
+                    "items": {"type": "number"},
+                    "description": "The compressed quantum state amplitudes",
+                },
+                "n_qubits": {
+                    "type": "integer",
+                    "description": "Number of qubits used in compression",
+                },
+                "original_length": {
+                    "type": "integer",
+                    "description": "Original number of tokens",
+                },
+            },
+            "required": ["compressed_state", "n_qubits", "original_length"],
+        },
+    },
+    {
+        "name": "quantum_gradient",
+        "description": "Compute gradients using quantum backpropagation via teleportation protocol. Achieves 97.78% gradient similarity with classical methods.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "weights": {
+                    "type": "array",
+                    "items": {"type": "number"},
+                    "description": "Neural network weights to compute gradients for",
+                },
+                "loss_value": {
+                    "type": "number",
+                    "description": "Current loss value",
+                },
+                "learning_rate": {
+                    "type": "number",
+                    "description": "Learning rate for gradient computation. Default: 0.01",
+                },
+            },
+            "required": ["weights", "loss_value"],
+        },
+    },
+    {
+        "name": "quantum_entangle",
+        "description": "Create quantum entanglement between data points for correlation analysis.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "data_a": {
+                    "type": "array",
+                    "items": {"type": "number"},
+                    "description": "First data array",
+                },
+                "data_b": {
+                    "type": "array",
+                    "items": {"type": "number"},
+                    "description": "Second data array",
+                },
+            },
+            "required": ["data_a", "data_b"],
+        },
+    },
+    {
+        "name": "quantum_teleport",
+        "description": "Teleport quantum state information using entangled Bell pairs.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "state": {
+                    "type": "array",
+                    "items": {"type": "number"},
+                    "description": "Quantum state amplitudes to teleport",
+                },
+                "n_pairs": {
+                    "type": "integer",
+                    "description": "Number of Bell pairs to use. Default: 10",
+                },
+            },
+            "required": ["state"],
+        },
+    },
+    {
+        "name": "qkd_exchange",
+        "description": "Perform BB84 quantum key distribution for unconditionally secure key exchange.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "key_length": {
+                    "type": "integer",
+                    "description": "Desired key length in bits. Default: 256",
+                },
+                "error_threshold": {
+                    "type": "number",
+                    "description": "Maximum acceptable error rate. Default: 0.11",
+                },
+            },
+            "required": [],
+        },
+    },
+    {
+        "name": "secure_message",
+        "description": "Send a message using quantum-secure encryption with QKD-generated keys.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "The message to encrypt and send",
+                },
+                "key_length": {
+                    "type": "integer",
+                    "description": "Key length for encryption. Default: 256",
+                },
+            },
+            "required": ["message"],
+        },
+    },
+    {
+        "name": "quantum_memory_store",
+        "description": "Store data in quantum memory with O(log n) space complexity.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "key": {
+                    "type": "string",
+                    "description": "Storage key identifier",
+                },
+                "data": {
+                    "type": "array",
+                    "items": {"type": "number"},
+                    "description": "Data to store",
+                },
+            },
+            "required": ["key", "data"],
+        },
+    },
+    {
+        "name": "quantum_memory_retrieve",
+        "description": "Retrieve data from quantum memory.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "key": {
+                    "type": "string",
+                    "description": "Storage key identifier",
+                },
+            },
+            "required": ["key"],
+        },
+    },
+]
+
+
+# Singleton instances for stateful operations
+_compressor: Optional[QuantumCompressor] = None
+_backprop: Optional[QuantumBackprop] = None
+_teleporter: Optional[QuantumTeleporter] = None
+_qkd: Optional[QKDExchange] = None
+_messenger: Optional[SecureMessenger] = None
+_entangler: Optional[Entangler] = None
+_memory: Optional[QuantumMemory] = None
+
+
+def _get_compressor(backend: str = "simulator") -> QuantumCompressor:
+    global _compressor
+    if _compressor is None:
+        _compressor = QuantumCompressor(backend=backend)
+    return _compressor
+
+
+def _get_backprop() -> QuantumBackprop:
+    global _backprop
+    if _backprop is None:
+        _backprop = QuantumBackprop()
+    return _backprop
+
+
+def _get_teleporter() -> QuantumTeleporter:
+    global _teleporter
+    if _teleporter is None:
+        _teleporter = QuantumTeleporter()
+    return _teleporter
+
+
+def _get_qkd() -> QKDExchange:
+    global _qkd
+    if _qkd is None:
+        _qkd = QKDExchange()
+    return _qkd
+
+
+def _get_messenger() -> SecureMessenger:
+    global _messenger
+    if _messenger is None:
+        _messenger = SecureMessenger()
+    return _messenger
+
+
+def _get_entangler() -> Entangler:
+    global _entangler
+    if _entangler is None:
+        _entangler = Entangler()
+    return _entangler
+
+
+def _get_memory() -> QuantumMemory:
+    global _memory
+    if _memory is None:
+        _memory = QuantumMemory()
+    return _memory
+
+
+def get_quantum_functions() -> List[Dict[str, Any]]:
+    """
+    Get the list of quantum function definitions for OpenAI's function calling API.
+
+    Returns:
+        List of function definitions compatible with OpenAI's API.
+
+    Example:
+        from openai import OpenAI
+        from quantumflow.integrations.openai_functions import get_quantum_functions
+
+        client = OpenAI()
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[...],
+            functions=get_quantum_functions(),
+            function_call="auto",
+        )
+    """
+    return QUANTUM_FUNCTIONS.copy()
+
+
+def get_quantum_tools() -> List[Dict[str, Any]]:
+    """
+    Get the list of quantum tools for OpenAI's tools API (newer format).
+
+    Returns:
+        List of tool definitions compatible with OpenAI's tools API.
+
+    Example:
+        from openai import OpenAI
+        from quantumflow.integrations.openai_functions import get_quantum_tools
+
+        client = OpenAI()
+        response = client.chat.completions.create(
+            model="gpt-4-turbo",
+            messages=[...],
+            tools=get_quantum_tools(),
+            tool_choice="auto",
+        )
+    """
+    return [
+        {"type": "function", "function": func}
+        for func in QUANTUM_FUNCTIONS
+    ]
+
+
+def execute_quantum_function(name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute a quantum function by name with the given arguments.
+
+    Args:
+        name: The function name to execute.
+        arguments: Dictionary of function arguments.
+
+    Returns:
+        Dictionary containing the function result.
+
+    Raises:
+        ValueError: If the function name is not recognized.
+
+    Example:
+        result = execute_quantum_function(
+            "quantum_compress",
+            {"tokens": [100, 200, 150, 175]}
+        )
+    """
+    handlers: Dict[str, Callable] = {
+        "quantum_compress": _handle_compress,
+        "quantum_decompress": _handle_decompress,
+        "quantum_gradient": _handle_gradient,
+        "quantum_entangle": _handle_entangle,
+        "quantum_teleport": _handle_teleport,
+        "qkd_exchange": _handle_qkd,
+        "secure_message": _handle_secure_message,
+        "quantum_memory_store": _handle_memory_store,
+        "quantum_memory_retrieve": _handle_memory_retrieve,
+    }
+
+    if name not in handlers:
+        raise ValueError(f"Unknown quantum function: {name}")
+
+    return handlers[name](arguments)
+
+
+def _handle_compress(args: Dict[str, Any]) -> Dict[str, Any]:
+    tokens = args["tokens"]
+    backend = args.get("backend", "simulator")
+    compressor = _get_compressor(backend)
+    result = compressor.compress(tokens)
+    return {
+        "success": True,
+        "compressed_state": result.amplitudes.tolist() if hasattr(result.amplitudes, 'tolist') else list(result.amplitudes),
+        "n_qubits": result.n_qubits,
+        "original_length": len(tokens),
+        "compression_percentage": result.compression_percentage,
+        "fidelity": result.fidelity,
+    }
+
+
+def _handle_decompress(args: Dict[str, Any]) -> Dict[str, Any]:
+    compressor = _get_compressor()
+    result = compressor.decompress(
+        compressed_state=args["compressed_state"],
+        n_qubits=args["n_qubits"],
+        original_length=args["original_length"],
+    )
+    return {
+        "success": True,
+        "tokens": result.tolist() if hasattr(result, 'tolist') else list(result),
+    }
+
+
+def _handle_gradient(args: Dict[str, Any]) -> Dict[str, Any]:
+    backprop = _get_backprop()
+    weights = args["weights"]
+    loss = args["loss_value"]
+    lr = args.get("learning_rate", 0.01)
+    result = backprop.compute_gradients(weights, loss, learning_rate=lr)
+    return {
+        "success": True,
+        "gradients": result.gradients.tolist() if hasattr(result.gradients, 'tolist') else list(result.gradients),
+        "similarity": result.similarity,
+        "teleportation_fidelity": result.fidelity,
+    }
+
+
+def _handle_entangle(args: Dict[str, Any]) -> Dict[str, Any]:
+    entangler = _get_entangler()
+    result = entangler.entangle(args["data_a"], args["data_b"])
+    return {
+        "success": True,
+        "correlation": result.correlation,
+        "bell_state": result.bell_state,
+        "fidelity": result.fidelity,
+    }
+
+
+def _handle_teleport(args: Dict[str, Any]) -> Dict[str, Any]:
+    teleporter = _get_teleporter()
+    n_pairs = args.get("n_pairs", 10)
+    result = teleporter.teleport(args["state"], n_pairs=n_pairs)
+    return {
+        "success": True,
+        "teleported_state": result.state.tolist() if hasattr(result.state, 'tolist') else list(result.state),
+        "fidelity": result.fidelity,
+        "bell_pairs_used": n_pairs,
+    }
+
+
+def _handle_qkd(args: Dict[str, Any]) -> Dict[str, Any]:
+    qkd = _get_qkd()
+    key_length = args.get("key_length", 256)
+    error_threshold = args.get("error_threshold", 0.11)
+    result = qkd.exchange(key_length=key_length, error_threshold=error_threshold)
+    return {
+        "success": True,
+        "key": result.key,
+        "key_length": len(result.key),
+        "error_rate": result.error_rate,
+        "secure": result.secure,
+    }
+
+
+def _handle_secure_message(args: Dict[str, Any]) -> Dict[str, Any]:
+    messenger = _get_messenger()
+    message = args["message"]
+    key_length = args.get("key_length", 256)
+    result = messenger.send_message(message, key_length=key_length)
+    return {
+        "success": True,
+        "encrypted": result.encrypted,
+        "message_hash": result.message_hash,
+        "key_id": result.key_id,
+    }
+
+
+def _handle_memory_store(args: Dict[str, Any]) -> Dict[str, Any]:
+    memory = _get_memory()
+    key = args["key"]
+    data = args["data"]
+    memory.store(key, data)
+    return {
+        "success": True,
+        "key": key,
+        "stored_length": len(data),
+        "quantum_bits_used": memory.get_usage(key),
+    }
+
+
+def _handle_memory_retrieve(args: Dict[str, Any]) -> Dict[str, Any]:
+    memory = _get_memory()
+    key = args["key"]
+    data = memory.retrieve(key)
+    if data is None:
+        return {
+            "success": False,
+            "error": f"Key '{key}' not found in quantum memory",
+        }
+    return {
+        "success": True,
+        "key": key,
+        "data": data.tolist() if hasattr(data, 'tolist') else list(data),
+    }
+
+
+@dataclass
+class QuantumAssistant:
+    """
+    A helper class for integrating QuantumFlow with OpenAI's chat completions.
+
+    Example:
+        from openai import OpenAI
+        from quantumflow.integrations.openai_functions import QuantumAssistant
+
+        client = OpenAI()
+        assistant = QuantumAssistant(client)
+
+        # Chat with quantum capabilities
+        response = assistant.chat("Compress these tokens: 100, 200, 150, 175")
+        print(response)
+    """
+
+    client: Any  # OpenAI client
+    model: str = "gpt-4"
+    messages: List[Dict[str, str]] = None
+
+    def __post_init__(self):
+        if self.messages is None:
+            self.messages = [
+                {
+                    "role": "system",
+                    "content": (
+                        "You are a quantum computing assistant with access to QuantumFlow tools. "
+                        "You can compress tokens, compute quantum gradients, perform quantum key distribution, "
+                        "send secure messages, and manage quantum memory. Use these tools to help users "
+                        "leverage quantum computing capabilities."
+                    ),
+                }
+            ]
+
+    def chat(self, user_message: str) -> str:
+        """
+        Send a message and get a response, automatically handling function calls.
+
+        Args:
+            user_message: The user's message.
+
+        Returns:
+            The assistant's response text.
+        """
+        self.messages.append({"role": "user", "content": user_message})
+
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=self.messages,
+            tools=get_quantum_tools(),
+            tool_choice="auto",
+        )
+
+        message = response.choices[0].message
+
+        # Handle tool calls
+        while message.tool_calls:
+            self.messages.append(message)
+
+            for tool_call in message.tool_calls:
+                function_name = tool_call.function.name
+                arguments = json.loads(tool_call.function.arguments)
+
+                try:
+                    result = execute_quantum_function(function_name, arguments)
+                    tool_response = json.dumps(result)
+                except Exception as e:
+                    tool_response = json.dumps({"error": str(e)})
+
+                self.messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": tool_response,
+                })
+
+            # Get next response
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=self.messages,
+                tools=get_quantum_tools(),
+                tool_choice="auto",
+            )
+            message = response.choices[0].message
+
+        # Final response
+        self.messages.append({"role": "assistant", "content": message.content})
+        return message.content
+
+    def reset(self):
+        """Reset the conversation history."""
+        self.__post_init__()

{quantumflow_sdk-0.1.0.dist-info → quantumflow_sdk-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantumflow-sdk
-Version: 0.1.0
+Version: 0.2.1
 Summary: Quantum-optimized AI agent workflow platform with 53% token compression
 Author-email: BlockQuantAI <hello@blockquant.ai>
 License-Expression: MIT

{quantumflow_sdk-0.1.0.dist-info → quantumflow_sdk-0.2.1.dist-info}/RECORD

@@ -9,7 +9,7 @@ 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
-quantumflow/__init__.py,sha256=FjUmp-TJl6O25iSYqCb1uhKyOgyOSffFmSExuHba89g,1284
+quantumflow/__init__.py,sha256=lUdk3uElyzBJe_VRjAjbehIULFDcbmvFePieaayWIwk,1731
 quantumflow/algorithms/__init__.py,sha256=waXASb2jnbAcjV-xS1wx-bGmPJ5lCj111dJ14eB8KCo,916
 quantumflow/algorithms/compression/__init__.py,sha256=rejDCdZJEy1tamQdDaZodGbo8wA1rszlXEtwvYgZO7A,361
 quantumflow/algorithms/compression/amplitude_amplification.py,sha256=pebJiATIhwEdnAZY4CwInYPEKbtZufJ0Ka3OCdtvZRk,5440
@@ -30,8 +30,9 @@ quantumflow/algorithms/utility/__init__.py,sha256=O-pY9GQ3i5DspBg-pLXFKz2QpLobL-
 quantumflow/algorithms/utility/circuit_optimizer.py,sha256=PsvSZA6teiO4soktMW2hiVKrTEieqw5ccKYjtV4T63I,5839
 quantumflow/algorithms/utility/error_correction.py,sha256=1L4ikcgasFwKYFSCxkx9Bk-Jz9En1KqZI-uGUScjsFw,9398
 quantumflow/api/__init__.py,sha256=WxcaYzyvrvOdWFlJn2AchfEm9Jy8ytFD9f0POaAF-f8,25
-quantumflow/api/routes/__init__.py,sha256=2WPtPte_1ZsrG9StXgcrqRPx-wPDFV8x1vn2FVtaBrY,130
+quantumflow/api/routes/__init__.py,sha256=qth1cwVYo7-9a1s44XjuusdHUoWHimgXjDkFW1sjCx8,226
 quantumflow/api/routes/billing_routes.py,sha256=MDvwkbVaXZhFl4_j5pgJ72_049a14u3fgAXxh314OdQ,16955
+quantumflow/api/routes/workflow_routes.py,sha256=4aiaOXPRq4MTQdbp2nHKEgcsoB6cugxKIuCKV1nDmog,6875
 quantumflow/backends/__init__.py,sha256=Q2Oi3VMp-AMXYN3QffsYd9NFz-qOaxgK_iSVCpVIivI,829
 quantumflow/backends/base_backend.py,sha256=cvvFcInPtzmzp1-uF796ciW3GpXgzaj4NJI2u_zsbL4,5408
 quantumflow/backends/braket_backend.py,sha256=vpWH0w6sQa_56SEBk_kvomKsuOJlb1ILANS-jUGcDv4,11527
@@ -46,15 +47,17 @@ quantumflow/core/memory.py,sha256=0rB2Dks3XM1NEiL-v4G0P6jeL2BvcdJNljezRrVccdI,44
 quantumflow/core/quantum_backprop.py,sha256=XozlPtwinegI5NosxlW4TrpP5Zh58_yI8WnxznwBHlU,12370
 quantumflow/core/quantum_compressor.py,sha256=okzfF4-1uL22FcK9Xhng1DLzmIbz3ADN-R1xzFTv-tI,10094
 quantumflow/core/teleportation.py,sha256=_T5rRItjFramqWdqBNLwu_fY7Yr9pmdUda4L7STcwcA,12420
-quantumflow/integrations/__init__.py,sha256=_QS8M9XxmBzRspuBCly6qocCopPCPsykFt-QhHWmfQ8,2571
+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/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_sdk-0.1.0.dist-info/METADATA,sha256=vKxocuo57XDRBrVSIXGWoYWMGQ_TvPEctPMsjpCbF7w,5461
-quantumflow_sdk-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-quantumflow_sdk-0.1.0.dist-info/entry_points.txt,sha256=ebX2acoOLgym42XZEqym3OfKCYiPz-mFuPSSGsHFz4c,53
-quantumflow_sdk-0.1.0.dist-info/top_level.txt,sha256=hEr_GRvoZ3-83naVIhNuJvoAND1aCvhBag_ynxQguIo,19
-quantumflow_sdk-0.1.0.dist-info/RECORD,,
+quantumflow/integrations/openai_functions.py,sha256=8jQH4XkBxK9AbwC47BEYVIrbRAEWGdsMyw0xbZrGNB4,18412
+quantumflow_sdk-0.2.1.dist-info/METADATA,sha256=QcTBk2aAfAE7goV311z5qrdubgYNhormcxUNdYqGsSI,5461
+quantumflow_sdk-0.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+quantumflow_sdk-0.2.1.dist-info/entry_points.txt,sha256=ebX2acoOLgym42XZEqym3OfKCYiPz-mFuPSSGsHFz4c,53
+quantumflow_sdk-0.2.1.dist-info/top_level.txt,sha256=hEr_GRvoZ3-83naVIhNuJvoAND1aCvhBag_ynxQguIo,19
+quantumflow_sdk-0.2.1.dist-info/RECORD,,