memra 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

memra/__init__.py

@@ -1,24 +1,27 @@
 """
-Memra SDK - Declarative framework for enterprise workflows with MCP integration
+Memra SDK - Declarative AI Workflows
 
-A powerful orchestration framework that allows you to build AI-powered business workflows
-with hybrid cloud/local execution capabilities.
+A framework for building AI-powered business workflows using a declarative approach.
+Think of it as "Kubernetes for business logic" where agents are the pods and 
+departments are the deployments.
 """
 
-__version__ = "0.2.0"
-__author__ = "Memra"
-__email__ = "info@memra.co"
+__version__ = "0.2.1"
 
 # Core imports
-from .models import Agent, Department, LLM, Tool
+from .models import Agent, Department, Tool
 from .execution import ExecutionEngine
 
 # Make key classes available at package level
 __all__ = [
     "Agent",
     "Department", 
-    "LLM",
     "Tool",
     "ExecutionEngine",
     "__version__"
-] 
+]
+
+# Optional: Add version check for compatibility
+import sys
+if sys.version_info < (3, 8):
+    raise RuntimeError("Memra requires Python 3.8 or higher") 

memra/execution.py

@@ -1,8 +1,8 @@
 import time
 import logging
-import os
 from typing import Dict, Any, List, Optional
 from .models import Department, Agent, DepartmentResult, ExecutionTrace, DepartmentAudit
+from .tool_registry import ToolRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -10,16 +10,7 @@ class ExecutionEngine:
     """Engine that executes department workflows by coordinating agents and tools"""
     
     def __init__(self):
-        # Use API client if MEMRA_API_KEY is set, otherwise use local tools
-        if os.getenv('MEMRA_API_KEY'):
-            from .tool_registry_client import ToolRegistryClient
-            self.tool_registry = ToolRegistryClient()
-            logger.info("Using API client for tool execution")
-        else:
-            from .tool_registry import ToolRegistry
-            self.tool_registry = ToolRegistry()
-            logger.info("Using local tool registry")
-        
+        self.tool_registry = ToolRegistry()
         self.last_execution_audit: Optional[DepartmentAudit] = None
     
     def execute_department(self, department: Department, input_data: Dict[str, Any]) -> DepartmentResult:
@@ -203,13 +194,6 @@ class ExecutionEngine:
                 tool_name = tool_spec["name"] if isinstance(tool_spec, dict) else tool_spec.name
                 hosted_by = tool_spec.get("hosted_by", "memra") if isinstance(tool_spec, dict) else tool_spec.hosted_by
                 
-                # Extract tool-level config if available, otherwise use agent config
-                tool_config = None
-                if isinstance(tool_spec, dict) and "config" in tool_spec:
-                    tool_config = tool_spec["config"]
-                elif agent.config:
-                    tool_config = agent.config
-                
                 print(f"⚡ {agent.role}: Using tool {i}/{len(agent.tools)}: {tool_name}")
                 
                 trace.tools_invoked.append(tool_name)
@@ -219,7 +203,7 @@ class ExecutionEngine:
                     tool_name, 
                     hosted_by, 
                     agent_input,
-                    tool_config
+                    agent.config
                 )
                 
                 if not tool_result.get("success", False):

memra/tool_registry.py

@@ -8,59 +8,41 @@ from pathlib import Path
 logger = logging.getLogger(__name__)
 
 class ToolRegistry:
-    """Registry for managing and executing tools"""
+    """Registry for managing and executing tools via API calls only"""
     
     def __init__(self):
         self.tools: Dict[str, Dict[str, Any]] = {}
-        self._add_project_to_path()
-        self._load_builtin_tools()
+        self._register_known_tools()
     
-    def _add_project_to_path(self):
-        """Add the project root to Python path so we can import logic modules"""
-        # Get the directory containing this file (memra package)
-        current_dir = Path(__file__).parent
-        # Go up one level to get the project root
-        project_root = current_dir.parent
+    def _register_known_tools(self):
+        """Register known tools with their metadata (no actual implementations)"""
+        # Server-hosted tools (executed via Memra API)
+        server_tools = [
+            ("DatabaseQueryTool", "Query database schemas and data"),
+            ("PDFProcessor", "Process PDF files and extract content"),
+            ("OCRTool", "Perform OCR on images and documents"),
+            ("InvoiceExtractionWorkflow", "Extract structured data from invoices"),
+            ("FileReader", "Read files from the filesystem"),
+        ]
         
-        if str(project_root) not in sys.path:
-            sys.path.insert(0, str(project_root))
-    
-    def _load_builtin_tools(self):
-        """Load tools from the logic directory"""
-        try:
-            # Load invoice tools
-            from logic.invoice_tools import (
-                DatabaseQueryTool, PDFProcessor, OCRTool, 
-                InvoiceExtractionWorkflow, DataValidator, PostgresInsert
-            )
-            
-            self.register_tool("DatabaseQueryTool", DatabaseQueryTool, "memra", 
-                             "Query database schemas and data")
-            self.register_tool("PDFProcessor", PDFProcessor, "memra", 
-                             "Process PDF files and extract content")
-            self.register_tool("OCRTool", OCRTool, "memra", 
-                             "Perform OCR on images and documents")
-            self.register_tool("InvoiceExtractionWorkflow", InvoiceExtractionWorkflow, "memra", 
-                             "Extract structured data from invoices")
-            self.register_tool("DataValidator", DataValidator, "memra", 
-                             "Validate data against schemas")
-            self.register_tool("PostgresInsert", PostgresInsert, "memra", 
-                             "Insert data into PostgreSQL database")
-            
-            # Load file tools
-            from logic.file_tools import FileReader
-            self.register_tool("FileReader", FileReader, "memra", 
-                             "Read files from the filesystem")
-            
-            logger.info(f"Loaded {len(self.tools)} builtin tools")
-            
-        except ImportError as e:
-            logger.warning(f"Could not load some tools: {e}")
+        for tool_name, description in server_tools:
+            self.register_tool(tool_name, None, "memra", description)
+        
+        # MCP-hosted tools (executed via MCP bridge)
+        mcp_tools = [
+            ("DataValidator", "Validate data against schemas"),
+            ("PostgresInsert", "Insert data into PostgreSQL database"),
+        ]
+        
+        for tool_name, description in mcp_tools:
+            self.register_tool(tool_name, None, "mcp", description)
+        
+        logger.info(f"Registered {len(self.tools)} tool definitions")
     
-    def register_tool(self, name: str, tool_class: type, hosted_by: str, description: str):
-        """Register a tool in the registry"""
+    def register_tool(self, name: str, tool_class: Optional[type], hosted_by: str, description: str):
+        """Register a tool in the registry (metadata only)"""
         self.tools[name] = {
-            "class": tool_class,
+            "class": tool_class,  # Will be None for API-based tools
             "hosted_by": hosted_by,
             "description": description
         }
@@ -80,111 +62,9 @@ class ToolRegistry:
     
     def execute_tool(self, tool_name: str, hosted_by: str, input_data: Dict[str, Any], 
                     config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Execute a tool with the given input data"""
-        if tool_name not in self.tools:
-            return {
-                "success": False,
-                "error": f"Tool '{tool_name}' not found in registry"
-            }
-        
-        tool_info = self.tools[tool_name]
-        if tool_info["hosted_by"] != hosted_by:
-            return {
-                "success": False,
-                "error": f"Tool '{tool_name}' is hosted by '{tool_info['hosted_by']}', not '{hosted_by}'"
-            }
-        
-        try:
-            # Instantiate tool
-            tool_class = tool_info["class"]
-            
-            # Some tools need credentials/config for initialization
-            if tool_name in ["DatabaseQueryTool", "PostgresInsert"]:
-                if "connection" in input_data:
-                    # Parse connection string or use credentials
-                    credentials = self._parse_connection(input_data["connection"])
-                    tool_instance = tool_class(credentials)
-                else:
-                    return {
-                        "success": False,
-                        "error": f"Tool '{tool_name}' requires database credentials"
-                    }
-            elif tool_name == "InvoiceExtractionWorkflow":
-                # This tool needs to be instantiated to initialize the LLM client
-                tool_instance = tool_class()
-            else:
-                tool_instance = tool_class()
-            
-            # Execute tool based on its type
-            result = self._execute_tool_method(tool_instance, tool_name, input_data, config)
-            
-            return {
-                "success": True,
-                "data": result
-            }
-            
-        except Exception as e:
-            logger.error(f"Tool execution failed for {tool_name}: {str(e)}")
-            return {
-                "success": False,
-                "error": str(e)
-            }
-    
-    def _execute_tool_method(self, tool_instance: Any, tool_name: str, 
-                           input_data: Dict[str, Any], config: Optional[Dict[str, Any]]) -> Dict[str, Any]:
-        """Execute the appropriate method on the tool instance"""
-        
-        if tool_name == "DatabaseQueryTool":
-            return tool_instance.get_schema("invoices")  # Default to invoices table
-        
-        elif tool_name == "PDFProcessor":
-            file_path = input_data.get("file", "")
-            return tool_instance.process_pdf(file_path)
-        
-        elif tool_name == "OCRTool":
-            # Assume PDF processor output is passed as input
-            return {"extracted_text": tool_instance.extract_text(input_data)}
-        
-        elif tool_name == "InvoiceExtractionWorkflow":
-            text = input_data.get("extracted_text", "")
-            schema = input_data.get("invoice_schema", {})
-            return tool_instance.extract_data(text, schema)
-        
-        elif tool_name == "DataValidator":
-            data = input_data.get("invoice_data", {})
-            schema = input_data.get("invoice_schema", {})
-            return tool_instance.validate(data, schema)
-        
-        elif tool_name == "PostgresInsert":
-            data = input_data.get("invoice_data", {})
-            return tool_instance.insert_record("invoices", data)
-        
-        elif tool_name == "FileReader":
-            file_path = config.get("path") if config else input_data.get("file_path")
-            if not file_path:
-                raise ValueError("FileReader requires a file path")
-            return tool_instance.read_file(file_path)
-        
-        else:
-            raise ValueError(f"Unknown tool execution method for {tool_name}")
-    
-    def _parse_connection(self, connection_string: str) -> Dict[str, Any]:
-        """Parse a connection string into credentials"""
-        # Simple parser for postgres://user:pass@host:port/database
-        if connection_string.startswith("postgres://"):
-            # This is a simplified parser - in production you'd use a proper URL parser
-            parts = connection_string.replace("postgres://", "").split("/")
-            db_part = parts[1] if len(parts) > 1 else "finance"
-            auth_host = parts[0].split("@")
-            host_port = auth_host[1].split(":") if len(auth_host) > 1 else ["localhost", "5432"]
-            user_pass = auth_host[0].split(":") if len(auth_host) > 1 else ["user", "pass"]
-            
-            return {
-                "host": host_port[0],
-                "port": int(host_port[1]) if len(host_port) > 1 else 5432,
-                "database": db_part,
-                "user": user_pass[0],
-                "password": user_pass[1] if len(user_pass) > 1 else ""
-            }
-        
-        return {"connection_string": connection_string} 
+        """Execute a tool - this should not be called directly in API-based mode"""
+        logger.warning(f"Direct tool execution attempted for {tool_name}. Use API client instead.")
+        return {
+            "success": False,
+            "error": "Direct tool execution not supported. Use API client for tool execution."
+        } 

{memra-0.2.0.dist-info → memra-0.2.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: memra
-Version: 0.2.0
-Summary: Declarative framework for enterprise workflows with MCP integration
+Version: 0.2.1
+Summary: Declarative framework for enterprise workflows with MCP integration - Client SDK
 Home-page: https://github.com/memra/memra-sdk
 Author: Memra
-Author-email: Memra <info@memra.co>
+Author-email: Memra <support@memra.com>
 License: MIT
 Project-URL: Homepage, https://memra.co
 Project-URL: Repository, https://github.com/memra-platform/memra-sdk
@@ -25,16 +25,13 @@ Requires-Dist: httpx>=0.24.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: aiohttp-cors>=0.7.0
-Requires-Dist: psycopg2-binary>=2.9.0
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
+Provides-Extra: mcp
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "mcp"
 
 # Memra SDK
 
@@ -131,31 +128,3 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 ├── local/dependencies/     # Database setup & schemas
 └── docker-compose.yml      # Database setup
 ```
-
-## ✨ New: MCP Integration
-
-Memra now supports **Model Context Protocol (MCP)** integration, allowing you to execute operations on your local infrastructure while leveraging Memra's cloud-based AI processing.
-
-**Key Benefits:**
-- 🔒 **Keep sensitive data local** - Your databases stay on your infrastructure
-- ⚡ **Hybrid processing** - AI processing in the cloud, data operations locally  
-- 🔐 **Secure communication** - HMAC-authenticated requests between cloud and local
-- 🛠️ **Easy setup** - Simple bridge server connects your local resources
-
-**Quick Example:**
-```python
-# Agent that uses local database via MCP
-agent = Agent(
-    role="Data Writer",
-    tools=[{
-        "name": "PostgresInsert",
-        "hosted_by": "mcp",  # Routes to your local infrastructure
-        "config": {
-            "bridge_url": "http://localhost:8081",
-            "bridge_secret": "your-secret"
-        }
-    }]
-)
-```
-
-📖 **[Complete MCP Integration Guide →](docs/mcp_integration.md)**

memra-0.2.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+memra/__init__.py,sha256=K3jA34FSI9LuDHAPyMFpG3cbX0pFVsTP2N5xzbUffiI,662
+memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
+memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
+memra/execution.py,sha256=3UIP69x2Ba89vv7OQ3yAzlnl1lphGagFPgKUrqcqElk,20172
+memra/models.py,sha256=nTaYLAp0tRzQ0CQaBLNBURfhBQ5_gyty0ams4mghyIc,3289
+memra/tool_registry.py,sha256=vnsuH5q20AMXADNl3-7HCD26x1zHc67waxxqv_Ta6Ak,2951
+memra/tool_registry_client.py,sha256=uzMQ4COvRams9vuPLcqcdljUpDlAYU_tyFxrRhrA0Lc,4009
+memra-0.2.1.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memra-0.2.1.dist-info/METADATA,sha256=LI5-Dte9XuNjsnM1KVs8Xr998nViC6jmI2S1nY37lkQ,3794
+memra-0.2.1.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+memra-0.2.1.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
+memra-0.2.1.dist-info/top_level.txt,sha256=pXWcTRS1zctdiSUivW4iyKpJ4tcfIu-1BW_fpbal3OY,6
+memra-0.2.1.dist-info/RECORD,,

{memra-0.2.0.dist-info → memra-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (75.7.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

memra-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+memra

memra-0.2.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-memra/__init__.py,sha256=XLSWpo42Ffp_pi5mvk4xvdYBZ8eNLAJF4_3Oi102i90,560
-memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
-memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
-memra/execution.py,sha256=5NIyFVtQEeatYQ-fxexT0eWMtCh28k1hRC2Y6cfQaac,20917
-memra/models.py,sha256=nTaYLAp0tRzQ0CQaBLNBURfhBQ5_gyty0ams4mghyIc,3289
-memra/tool_registry.py,sha256=zdyKRShcmKtG7BVfmAHflW9FDl7rooPPAgbdVV4gJ8o,8268
-memra/tool_registry_client.py,sha256=uzMQ4COvRams9vuPLcqcdljUpDlAYU_tyFxrRhrA0Lc,4009
-memra-0.2.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-memra-sdk-package/examples/accounts_payable_client.py,sha256=Vu_h5C-qc6_80uz5dXJH4G3zfIbgUNAhQ2y8mWauao0,7401
-memra-sdk-package/memra/__init__.py,sha256=QRk72YETLgL15GVt26tN_rBraCQkhZO7UB9T6d4u_uU,543
-memra-sdk-package/memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
-memra-sdk-package/memra/execution.py,sha256=UJ_MJ4getuSk4HJW1sCi7lc26avX-G6-GxnvE-DiSwk,20191
-memra-sdk-package/memra/models.py,sha256=nTaYLAp0tRzQ0CQaBLNBURfhBQ5_gyty0ams4mghyIc,3289
-memra-sdk-package/memra/tool_registry_client.py,sha256=KyNNxj84248E-8MoWNj6pJmlllUG8s0lmeXXmbu0U7o,3996
-memra-0.2.0.dist-info/METADATA,sha256=eOuvH39VFUh-QxTdE5RwT6isgRIJkptEC2lsqlF2AA4,4816
-memra-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-memra-0.2.0.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
-memra-0.2.0.dist-info/top_level.txt,sha256=5dqePB77aj_pPFavlwxtBvdkUM-kP-WiQD3LRbQswwc,24
-memra-0.2.0.dist-info/RECORD,,

memra-0.2.0.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-memra
-memra-sdk-package

memra-sdk-package/examples/accounts_payable_client.py

@@ -1,207 +0,0 @@
-"""
-Client-side Accounts Payable Example
-This version calls the Memra API hosted on Fly.io instead of running tools locally
-"""
-
-import os
-from memra import Agent, Department, LLM, check_api_health, get_api_status
-from memra.execution import ExecutionEngine
-
-# Set API configuration
-os.environ["MEMRA_API_URL"] = "http://localhost:8080"  # Use local API for testing
-os.environ["MEMRA_API_KEY"] = "dev-key"
-
-# Check API health before starting
-print("🔍 Checking Memra API status...")
-api_status = get_api_status()
-print(f"API Health: {'✅ Healthy' if api_status['api_healthy'] else '❌ Unavailable'}")
-print(f"API URL: {api_status['api_url']}")
-print(f"Tools Available: {api_status['tools_available']}")
-
-if not api_status['api_healthy']:
-    print("❌ Cannot proceed - Memra API is not available")
-    print("Make sure the API server is running on localhost:8080")
-    exit(1)
-
-# Define LLMs (these are just metadata - actual LLM calls happen on the server)
-default_llm = LLM(
-    model="llama-3.2-11b-vision-preview",
-    temperature=0.1,
-    max_tokens=2000
-)
-
-parsing_llm = LLM(
-    model="llama-3.2-11b-vision-preview", 
-    temperature=0.0,
-    max_tokens=4000
-)
-
-manager_llm = LLM(
-    model="llama-3.2-11b-vision-preview",
-    temperature=0.2,
-    max_tokens=1000
-)
-
-# Define agents (same declarative interface as before)
-etl_agent = Agent(
-    role="Data Engineer",
-    job="Extract invoice schema from database",
-    llm=default_llm,
-    sops=[
-        "Connect to database using credentials",
-        "Query information_schema for invoices table", 
-        "Extract column names, types, and constraints",
-        "Return schema as structured JSON"
-    ],
-    systems=["Database"],
-    tools=[
-        {"name": "DatabaseQueryTool", "hosted_by": "memra"}
-    ],
-    output_key="invoice_schema"
-)
-
-parser_agent = Agent(
-    role="Invoice Parser",
-    job="Extract structured data from invoice PDF using schema",
-    llm=parsing_llm,
-    sops=[
-        "Load invoice PDF file",
-        "Convert to high-contrast images if needed", 
-        "Run OCR to extract text",
-        "Use schema to identify and extract fields",
-        "Validate extracted data against schema types",
-        "Return structured invoice data"
-    ],
-    systems=["InvoiceStore"],
-    tools=[
-        {"name": "PDFProcessor", "hosted_by": "memra"},
-        {"name": "OCRTool", "hosted_by": "memra"},
-        {"name": "InvoiceExtractionWorkflow", "hosted_by": "memra"}
-    ],
-    input_keys=["file", "invoice_schema"],
-    output_key="invoice_data"
-)
-
-writer_agent = Agent(
-    role="Data Entry Specialist", 
-    job="Write validated invoice data to database",
-    llm=default_llm,
-    sops=[
-        "Validate invoice data completeness",
-        "Map fields to database columns using schema",
-        "Connect to database",
-        "Insert record into invoices table",
-        "Return confirmation with record ID"
-    ],
-    systems=["Database"],
-    tools=[
-        {"name": "DataValidator", "hosted_by": "memra"},
-        {"name": "PostgresInsert", "hosted_by": "memra"}
-    ],
-    input_keys=["invoice_data", "invoice_schema"],
-    output_key="write_confirmation"
-)
-
-manager_agent = Agent(
-    role="Accounts Payable Manager",
-    job="Coordinate invoice processing pipeline and handle exceptions",
-    llm=manager_llm,
-    sops=[
-        "Check if schema extraction succeeded",
-        "Validate parsed invoice has required fields", 
-        "Ensure invoice total matches line items before DB write",
-        "Handle and log any errors with appropriate escalation"
-    ],
-    allow_delegation=True,
-    output_key="workflow_status"
-)
-
-# Create department
-ap_department = Department(
-    name="Accounts Payable",
-    mission="Process invoices accurately into financial system per company data standards",
-    agents=[etl_agent, parser_agent, writer_agent],
-    manager_agent=manager_agent,
-    workflow_order=["Data Engineer", "Invoice Parser", "Data Entry Specialist"],
-    dependencies=["Database", "InvoiceStore"],
-    execution_policy={
-        "retry_on_fail": True,
-        "max_retries": 2,
-        "halt_on_validation_error": True,
-        "timeout_seconds": 300
-    },
-    context={
-        "company_id": "acme_corp",
-        "fiscal_year": "2024"
-    }
-)
-
-# Execute the department (tools will run on Fly.io)
-print("\n🚀 Starting invoice processing workflow...")
-print("📡 Tools will execute on Memra API server")
-
-engine = ExecutionEngine()
-input_data = {
-    "file": "invoices/10352259310.PDF",
-    "connection": "postgresql://tarpus@localhost:5432/memra_invoice_db"
-}
-
-result = engine.execute_department(ap_department, input_data)
-
-# Display results (same as before)
-if result.success:
-    print("✅ Invoice processing completed successfully!")
-    
-    # Show manager validation results
-    if 'workflow_status' in result.data:
-        manager_report = result.data['workflow_status']
-        print(f"\n🔍 Manager Validation Report:")
-        print(f"Status: {manager_report.get('validation_status', 'unknown')}")
-        print(f"Summary: {manager_report.get('summary', 'No summary available')}")
-        
-        # Show agent performance analysis
-        if 'agent_performance' in manager_report:
-            print(f"\n📊 Agent Performance Analysis:")
-            for agent_role, performance in manager_report['agent_performance'].items():
-                work_quality = performance['work_quality']
-                status_emoji = "✅" if work_quality == "real" else "🔄"
-                print(f"{status_emoji} {agent_role}: {performance['status']}")
-                if performance['tools_real_work']:
-                    print(f"   Real work: {', '.join(performance['tools_real_work'])}")
-                if performance['tools_mock_work']:
-                    print(f"   Mock work: {', '.join(performance['tools_mock_work'])}")
-        
-        # Show workflow analysis
-        if 'workflow_analysis' in manager_report:
-            analysis = manager_report['workflow_analysis']
-            print(f"\n📈 Workflow Analysis:")
-            print(f"Overall Quality: {analysis['overall_quality']}")
-            print(f"Real Work: {analysis['real_work_agents']}/{analysis['total_agents']} agents ({analysis['real_work_percentage']:.1f}%)")
-        
-        # Show recommendations
-        if 'recommendations' in manager_report and manager_report['recommendations']:
-            print(f"\n💡 Recommendations:")
-            for rec in manager_report['recommendations']:
-                print(f"   • {rec}")
-    
-    # Try to get record_id if it exists
-    if result.data and 'write_confirmation' in result.data:
-        confirmation = result.data['write_confirmation']
-        if isinstance(confirmation, dict) and 'record_id' in confirmation:
-            print(f"\n💾 Invoice processed successfully: Record ID {confirmation['record_id']}")
-        else:
-            print(f"\n💾 Write confirmation: {confirmation}")
-    
-    print(f"\n📡 All tools executed remotely on Memra API server")
-    
-else:
-    print(f"❌ Processing failed: {result.error}")
-
-# Show execution trace
-print("\n=== Execution Trace ===")
-print(f"Agents executed: {', '.join(result.trace.agents_executed)}")
-print(f"Tools invoked: {', '.join(result.trace.tools_invoked)}")
-if result.trace.errors:
-    print(f"Errors: {', '.join(result.trace.errors)}")
-
-print(f"\n🌐 API Calls made to: {api_status['api_url']}") 

memra-sdk-package/memra/__init__.py

@@ -1,28 +0,0 @@
-"""
-Memra SDK - A declarative orchestration framework for AI-powered business workflows
-"""
-
-from .models import (
-    Agent, 
-    Department, 
-    LLM, 
-    Tool, 
-    ExecutionPolicy, 
-    ExecutionTrace, 
-    DepartmentResult, 
-    DepartmentAudit
-)
-from .discovery_client import discover_tools, check_api_health, get_api_status
-
-__version__ = "0.1.2"
-__all__ = [
-    "Agent", 
-    "Department", 
-    "LLM", 
-    "Tool", 
-    "ExecutionPolicy", 
-    "ExecutionTrace", 
-    "DepartmentResult", 
-    "DepartmentAudit",
-    "discover_tools"
-] 

memra-sdk-package/memra/discovery_client.py

@@ -1,49 +0,0 @@
-"""
-Client-side tool discovery for Memra SDK
-Queries the Memra API to discover available tools
-"""
-
-from typing import List, Dict, Any, Optional
-from .tool_registry_client import ToolRegistryClient
-
-def discover_tools(hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
-    """
-    Discover available tools from the Memra API
-    
-    Args:
-        hosted_by: Filter tools by hosting provider ("memra" or "mcp")
-        
-    Returns:
-        List of available tools with their descriptions
-    """
-    registry = ToolRegistryClient()
-    return registry.discover_tools(hosted_by)
-
-def check_api_health() -> bool:
-    """
-    Check if the Memra API is available
-    
-    Returns:
-        True if API is healthy, False otherwise
-    """
-    registry = ToolRegistryClient()
-    return registry.health_check()
-
-def get_api_status() -> Dict[str, Any]:
-    """
-    Get detailed API status information
-    
-    Returns:
-        Dictionary with API status details
-    """
-    registry = ToolRegistryClient()
-    
-    is_healthy = registry.health_check()
-    tools = registry.discover_tools() if is_healthy else []
-    
-    return {
-        "api_healthy": is_healthy,
-        "api_url": registry.api_base,
-        "tools_available": len(tools),
-        "tools": tools
-    } 

memra-sdk-package/memra/execution.py

@@ -1,418 +0,0 @@
-import time
-import logging
-from typing import Dict, Any, List, Optional
-from .models import Department, Agent, DepartmentResult, ExecutionTrace, DepartmentAudit
-from .tool_registry_client import ToolRegistryClient
-
-logger = logging.getLogger(__name__)
-
-class ExecutionEngine:
-    """Engine that executes department workflows by coordinating agents and tools"""
-    
-    def __init__(self):
-        self.tool_registry = ToolRegistryClient()
-        self.last_execution_audit: Optional[DepartmentAudit] = None
-    
-    def execute_department(self, department: Department, input_data: Dict[str, Any]) -> DepartmentResult:
-        """Execute a department workflow"""
-        start_time = time.time()
-        trace = ExecutionTrace()
-        
-        try:
-            print(f"\n🏢 Starting {department.name} Department")
-            print(f"📋 Mission: {department.mission}")
-            print(f"👥 Team: {', '.join([agent.role for agent in department.agents])}")
-            if department.manager_agent:
-                print(f"👔 Manager: {department.manager_agent.role}")
-            print(f"🔄 Workflow: {' → '.join(department.workflow_order)}")
-            print("=" * 60)
-            
-            logger.info(f"Starting execution of department: {department.name}")
-            
-            # Initialize execution context
-            context = {
-                "input": input_data,
-                "department_context": department.context or {},
-                "results": {}
-            }
-            
-            # Execute agents in workflow order
-            for i, agent_role in enumerate(department.workflow_order, 1):
-                print(f"\n🔄 Step {i}/{len(department.workflow_order)}: {agent_role}")
-                
-                agent = self._find_agent_by_role(department, agent_role)
-                if not agent:
-                    error_msg = f"Agent with role '{agent_role}' not found in department"
-                    print(f"❌ Error: {error_msg}")
-                    trace.errors.append(error_msg)
-                    return DepartmentResult(
-                        success=False,
-                        error=error_msg,
-                        trace=trace
-                    )
-                
-                # Execute agent
-                agent_start = time.time()
-                result = self._execute_agent(agent, context, trace)
-                agent_duration = time.time() - agent_start
-                
-                trace.agents_executed.append(agent.role)
-                trace.execution_times[agent.role] = agent_duration
-                
-                if not result.get("success", False):
-                    # Try fallback if available
-                    if department.manager_agent and agent.role in (department.manager_agent.fallback_agents or {}):
-                        fallback_role = department.manager_agent.fallback_agents[agent.role]
-                        print(f"🔄 {department.manager_agent.role}: Let me try {fallback_role} as backup for {agent.role}")
-                        fallback_agent = self._find_agent_by_role(department, fallback_role)
-                        if fallback_agent:
-                            logger.info(f"Trying fallback agent: {fallback_role}")
-                            result = self._execute_agent(fallback_agent, context, trace)
-                            trace.agents_executed.append(fallback_agent.role)
-                    
-                    if not result.get("success", False):
-                        error_msg = f"Agent {agent.role} failed: {result.get('error', 'Unknown error')}"
-                        print(f"❌ Workflow stopped: {error_msg}")
-                        trace.errors.append(error_msg)
-                        return DepartmentResult(
-                            success=False,
-                            error=error_msg,
-                            trace=trace
-                        )
-                
-                # Store result for next agent
-                context["results"][agent.output_key] = result.get("data")
-                print(f"✅ Step {i} completed in {agent_duration:.1f}s")
-            
-            # Execute manager agent for final validation if present
-            if department.manager_agent:
-                print(f"\n🔍 Final Review Phase")
-                manager_start = time.time()
-                
-                # Prepare manager input with all workflow results
-                manager_input = {
-                    "workflow_results": context["results"],
-                    "department_context": context["department_context"]
-                }
-                
-                # Add connection if available
-                if "connection" in context["input"]:
-                    manager_input["connection"] = context["input"]["connection"]
-                
-                # Execute manager validation
-                manager_result = self._execute_manager_validation(department.manager_agent, manager_input, trace)
-                manager_duration = time.time() - manager_start
-                
-                trace.agents_executed.append(department.manager_agent.role)
-                trace.execution_times[department.manager_agent.role] = manager_duration
-                
-                # Store manager validation results
-                context["results"][department.manager_agent.output_key] = manager_result.get("data")
-                
-                # Check if manager validation failed
-                if not manager_result.get("success", False):
-                    error_msg = f"Manager validation failed: {manager_result.get('error', 'Unknown error')}"
-                    print(f"❌ {error_msg}")
-                    trace.errors.append(error_msg)
-                    return DepartmentResult(
-                        success=False,
-                        error=error_msg,
-                        trace=trace
-                    )
-                
-                print(f"✅ Manager review completed in {manager_duration:.1f}s")
-            
-            # Create audit record
-            total_duration = time.time() - start_time
-            self.last_execution_audit = DepartmentAudit(
-                agents_run=trace.agents_executed,
-                tools_invoked=trace.tools_invoked,
-                duration_seconds=total_duration
-            )
-            
-            print(f"\n🎉 {department.name} Department workflow completed!")
-            print(f"⏱️ Total time: {total_duration:.1f}s")
-            print("=" * 60)
-            
-            return DepartmentResult(
-                success=True,
-                data=context["results"],
-                trace=trace
-            )
-            
-        except Exception as e:
-            print(f"💥 Unexpected error in {department.name} Department: {str(e)}")
-            logger.error(f"Execution failed: {str(e)}")
-            trace.errors.append(str(e))
-            return DepartmentResult(
-                success=False,
-                error=str(e),
-                trace=trace
-            )
-    
-    def _find_agent_by_role(self, department: Department, role: str) -> Optional[Agent]:
-        """Find an agent by role in the department"""
-        for agent in department.agents:
-            if agent.role == role:
-                return agent
-        return None
-    
-    def _execute_agent(self, agent: Agent, context: Dict[str, Any], trace: ExecutionTrace) -> Dict[str, Any]:
-        """Execute a single agent"""
-        print(f"\n👤 {agent.role}: Hi! I'm starting my work now...")
-        logger.info(f"Executing agent: {agent.role}")
-        
-        try:
-            # Show what the agent is thinking about
-            print(f"💭 {agent.role}: My job is to {agent.job.lower()}")
-            
-            # Prepare input data for agent
-            agent_input = {}
-            for key in agent.input_keys:
-                if key in context["input"]:
-                    agent_input[key] = context["input"][key]
-                    print(f"📥 {agent.role}: I received '{key}' as input")
-                elif key in context["results"]:
-                    agent_input[key] = context["results"][key]
-                    print(f"📥 {agent.role}: I got '{key}' from a previous agent")
-                else:
-                    print(f"🤔 {agent.role}: Hmm, I'm missing input '{key}' but I'll try to work without it")
-                    logger.warning(f"Missing input key '{key}' for agent {agent.role}")
-            
-            # Always include connection string if available (for database tools)
-            if "connection" in context["input"]:
-                agent_input["connection"] = context["input"]["connection"]
-            
-            # Execute agent's tools
-            result_data = {}
-            tools_with_real_work = []
-            tools_with_mock_work = []
-            
-            print(f"🔧 {agent.role}: I need to use {len(agent.tools)} tool(s) to complete my work...")
-            
-            for i, tool_spec in enumerate(agent.tools, 1):
-                tool_name = tool_spec["name"] if isinstance(tool_spec, dict) else tool_spec.name
-                hosted_by = tool_spec.get("hosted_by", "memra") if isinstance(tool_spec, dict) else tool_spec.hosted_by
-                
-                print(f"⚡ {agent.role}: Using tool {i}/{len(agent.tools)}: {tool_name}")
-                
-                trace.tools_invoked.append(tool_name)
-                
-                # Get tool from registry and execute
-                tool_result = self.tool_registry.execute_tool(
-                    tool_name, 
-                    hosted_by, 
-                    agent_input,
-                    agent.config
-                )
-                
-                if not tool_result.get("success", False):
-                    print(f"😟 {agent.role}: Oh no! Tool {tool_name} failed: {tool_result.get('error', 'Unknown error')}")
-                    return {
-                        "success": False,
-                        "error": f"Tool {tool_name} failed: {tool_result.get('error', 'Unknown error')}"
-                    }
-                
-                # Check if this tool did real work or mock work
-                tool_data = tool_result.get("data", {})
-                if self._is_real_work(tool_name, tool_data):
-                    tools_with_real_work.append(tool_name)
-                    print(f"✅ {agent.role}: Great! {tool_name} did real work and gave me useful results")
-                else:
-                    tools_with_mock_work.append(tool_name)
-                    print(f"🔄 {agent.role}: {tool_name} gave me simulated results (that's okay for testing)")
-                
-                result_data.update(tool_data)
-            
-            # Add metadata about real vs mock work
-            result_data["_memra_metadata"] = {
-                "agent_role": agent.role,
-                "tools_real_work": tools_with_real_work,
-                "tools_mock_work": tools_with_mock_work,
-                "work_quality": "real" if tools_with_real_work else "mock"
-            }
-            
-            # Agent reports completion
-            if tools_with_real_work:
-                print(f"🎉 {agent.role}: Perfect! I completed my work with real data processing")
-            else:
-                print(f"📝 {agent.role}: I finished my work, but used simulated data (still learning!)")
-            
-            print(f"📤 {agent.role}: Passing my results to the next agent via '{agent.output_key}'")
-            
-            return {
-                "success": True,
-                "data": result_data
-            }
-            
-        except Exception as e:
-            print(f"😰 {agent.role}: I encountered an error and couldn't complete my work: {str(e)}")
-            logger.error(f"Agent {agent.role} execution failed: {str(e)}")
-            return {
-                "success": False,
-                "error": str(e)
-            }
-    
-    def _is_real_work(self, tool_name: str, tool_data: Dict[str, Any]) -> bool:
-        """Determine if a tool did real work or returned mock data"""
-        
-        # Check for specific indicators of real work
-        if tool_name == "PDFProcessor":
-            # Real work if it has actual image paths and file size
-            return (
-                "metadata" in tool_data and 
-                "file_size" in tool_data["metadata"] and
-                tool_data["metadata"]["file_size"] > 1000 and  # Real file size
-                "pages" in tool_data and
-                len(tool_data["pages"]) > 0 and
-                "image_path" in tool_data["pages"][0]
-            )
-        
-        elif tool_name == "InvoiceExtractionWorkflow":
-            # Real work if it has actual extracted data with specific vendor info
-            return (
-                "headerSection" in tool_data and
-                "vendorName" in tool_data["headerSection"] and
-                tool_data["headerSection"]["vendorName"] not in ["", "UNKNOWN", "Sample Vendor"] and
-                "chargesSummary" in tool_data and
-                "memra_checksum" in tool_data["chargesSummary"]
-            )
-        
-        elif tool_name == "DatabaseQueryTool":
-            # Real work if it loaded the actual schema file (more than 3 columns)
-            return (
-                "columns" in tool_data and
-                len(tool_data["columns"]) > 3
-            )
-        
-        elif tool_name == "DataValidator":
-            # Real work if it actually validated real data with meaningful validation
-            return (
-                "validation_errors" in tool_data and
-                isinstance(tool_data["validation_errors"], list) and
-                "is_valid" in tool_data and
-                # Check if it's validating real extracted data (not just mock data)
-                len(str(tool_data)) > 100  # Real validation results are more substantial
-            )
-        
-        elif tool_name == "PostgresInsert":
-            # Real work if it successfully inserted into a real database
-            return (
-                "success" in tool_data and
-                tool_data["success"] == True and
-                "record_id" in tool_data and
-                isinstance(tool_data["record_id"], int) and  # Real DB returns integer IDs
-                "database_table" in tool_data  # Real implementation includes table name
-            )
-        
-        # Default to mock work
-        return False
-    
-    def get_last_audit(self) -> Optional[DepartmentAudit]:
-        """Get audit information from the last execution"""
-        return self.last_execution_audit 
-    
-    def _execute_manager_validation(self, manager_agent: Agent, manager_input: Dict[str, Any], trace: ExecutionTrace) -> Dict[str, Any]:
-        """Execute manager agent to validate workflow results"""
-        print(f"\n👔 {manager_agent.role}: Time for me to review everyone's work...")
-        logger.info(f"Manager {manager_agent.role} validating workflow results")
-        
-        try:
-            # Analyze workflow results for real vs mock work
-            workflow_analysis = self._analyze_workflow_quality(manager_input["workflow_results"])
-            
-            print(f"🔍 {manager_agent.role}: Let me analyze what each agent accomplished...")
-            
-            # Prepare validation report
-            validation_report = {
-                "workflow_analysis": workflow_analysis,
-                "validation_status": "pass" if workflow_analysis["overall_quality"] == "real" else "fail",
-                "recommendations": [],
-                "agent_performance": {}
-            }
-            
-            # Analyze each agent's performance
-            for result_key, result_data in manager_input["workflow_results"].items():
-                if isinstance(result_data, dict) and "_memra_metadata" in result_data:
-                    metadata = result_data["_memra_metadata"]
-                    agent_role = metadata["agent_role"]
-                    
-                    if metadata["work_quality"] == "real":
-                        print(f"👍 {manager_agent.role}: {agent_role} did excellent real work!")
-                    else:
-                        print(f"📋 {manager_agent.role}: {agent_role} completed their tasks but with simulated data")
-                    
-                    validation_report["agent_performance"][agent_role] = {
-                        "work_quality": metadata["work_quality"],
-                        "tools_real_work": metadata["tools_real_work"],
-                        "tools_mock_work": metadata["tools_mock_work"],
-                        "status": "completed_real_work" if metadata["work_quality"] == "real" else "completed_mock_work"
-                    }
-                    
-                    # Add recommendations for mock work
-                    if metadata["work_quality"] == "mock":
-                        recommendation = f"Agent {agent_role} performed mock work - implement real {', '.join(metadata['tools_mock_work'])} functionality"
-                        validation_report["recommendations"].append(recommendation)
-                        print(f"💡 {manager_agent.role}: I recommend upgrading {agent_role}'s tools for production")
-            
-            # Overall workflow validation
-            if workflow_analysis["overall_quality"] == "real":
-                validation_report["summary"] = "Workflow completed successfully with real data processing"
-                print(f"🎯 {manager_agent.role}: Excellent! This workflow is production-ready")
-            elif workflow_analysis["overall_quality"].startswith("mixed"):
-                validation_report["summary"] = "Workflow completed with mixed real and simulated data"
-                print(f"⚖️ {manager_agent.role}: Good progress! Some agents are production-ready, others need work")
-            else:
-                validation_report["summary"] = "Workflow completed but with mock/simulated data - production readiness requires real implementations"
-                print(f"🚧 {manager_agent.role}: This workflow needs more development before production use")
-            
-            real_percentage = workflow_analysis["real_work_percentage"]
-            print(f"📊 {manager_agent.role}: Overall assessment: {real_percentage:.0f}% of agents did real work")
-            
-            return {
-                "success": True,
-                "data": validation_report
-            }
-            
-        except Exception as e:
-            print(f"😰 {manager_agent.role}: I had trouble analyzing the workflow: {str(e)}")
-            logger.error(f"Manager validation failed: {str(e)}")
-            return {
-                "success": False,
-                "error": str(e)
-            }
-    
-    def _analyze_workflow_quality(self, workflow_results: Dict[str, Any]) -> Dict[str, Any]:
-        """Analyze the overall quality of workflow execution"""
-        
-        total_agents = 0
-        real_work_agents = 0
-        mock_work_agents = 0
-        
-        for result_key, result_data in workflow_results.items():
-            if isinstance(result_data, dict) and "_memra_metadata" in result_data:
-                metadata = result_data["_memra_metadata"]
-                total_agents += 1
-                
-                if metadata["work_quality"] == "real":
-                    real_work_agents += 1
-                else:
-                    mock_work_agents += 1
-        
-        # Determine overall quality
-        if real_work_agents > 0 and mock_work_agents == 0:
-            overall_quality = "real"
-        elif real_work_agents > mock_work_agents:
-            overall_quality = "mixed_mostly_real"
-        elif real_work_agents > 0:
-            overall_quality = "mixed_mostly_mock"
-        else:
-            overall_quality = "mock"
-        
-        return {
-            "total_agents": total_agents,
-            "real_work_agents": real_work_agents,
-            "mock_work_agents": mock_work_agents,
-            "overall_quality": overall_quality,
-            "real_work_percentage": (real_work_agents / total_agents * 100) if total_agents > 0 else 0
-        } 

memra-sdk-package/memra/models.py

@@ -1,98 +0,0 @@
-from typing import List, Dict, Optional, Any, Union
-from pydantic import BaseModel, Field
-
-class LLM(BaseModel):
-    model: str
-    temperature: float = 0.0
-    max_tokens: Optional[int] = None
-    stop: Optional[List[str]] = None
-
-class Tool(BaseModel):
-    name: str
-    hosted_by: str = "memra"  # or "mcp" for customer's Model Context Protocol
-    description: Optional[str] = None
-    parameters: Optional[Dict[str, Any]] = None
-
-class Agent(BaseModel):
-    role: str
-    job: str
-    llm: Optional[Union[LLM, Dict[str, Any]]] = None
-    sops: List[str] = Field(default_factory=list)
-    tools: List[Union[Tool, Dict[str, Any]]] = Field(default_factory=list)
-    systems: List[str] = Field(default_factory=list)
-    input_keys: List[str] = Field(default_factory=list)
-    output_key: str
-    allow_delegation: bool = False
-    fallback_agents: Optional[Dict[str, str]] = None
-    config: Optional[Dict[str, Any]] = None
-
-class ExecutionPolicy(BaseModel):
-    retry_on_fail: bool = True
-    max_retries: int = 2
-    halt_on_validation_error: bool = True
-    timeout_seconds: int = 300
-
-class ExecutionTrace(BaseModel):
-    agents_executed: List[str] = Field(default_factory=list)
-    tools_invoked: List[str] = Field(default_factory=list)
-    execution_times: Dict[str, float] = Field(default_factory=dict)
-    errors: List[str] = Field(default_factory=list)
-    
-    def show(self):
-        """Display execution trace information"""
-        print("=== Execution Trace ===")
-        print(f"Agents executed: {', '.join(self.agents_executed)}")
-        print(f"Tools invoked: {', '.join(self.tools_invoked)}")
-        if self.errors:
-            print(f"Errors: {', '.join(self.errors)}")
-
-class DepartmentResult(BaseModel):
-    success: bool
-    data: Optional[Dict[str, Any]] = None
-    error: Optional[str] = None
-    trace: ExecutionTrace = Field(default_factory=ExecutionTrace)
-
-class DepartmentAudit(BaseModel):
-    agents_run: List[str]
-    tools_invoked: List[str]
-    duration_seconds: float
-    total_cost: Optional[float] = None
-
-class Department(BaseModel):
-    name: str
-    mission: str
-    agents: List[Agent]
-    manager_agent: Optional[Agent] = None
-    default_llm: Optional[LLM] = None
-    workflow_order: List[str] = Field(default_factory=list)
-    dependencies: List[str] = Field(default_factory=list)
-    execution_policy: Optional[ExecutionPolicy] = None
-    context: Optional[Dict[str, Any]] = None
-
-    def run(self, input: Dict[str, Any]) -> DepartmentResult:
-        """
-        Execute the department workflow with the given input data.
-        """
-        # Import here to avoid circular imports
-        from .execution import ExecutionEngine
-        
-        engine = ExecutionEngine()
-        return engine.execute_department(self, input)
-    
-    def audit(self) -> DepartmentAudit:
-        """
-        Return audit information about the last execution.
-        """
-        # Import here to avoid circular imports
-        from .execution import ExecutionEngine
-        
-        engine = ExecutionEngine()
-        audit = engine.get_last_audit()
-        if audit:
-            return audit
-        else:
-            return DepartmentAudit(
-                agents_run=[],
-                tools_invoked=[],
-                duration_seconds=0.0
-            ) 

memra-sdk-package/memra/tool_registry_client.py

@@ -1,105 +0,0 @@
-import httpx
-import logging
-import os
-from typing import Dict, Any, List, Optional
-import asyncio
-
-logger = logging.getLogger(__name__)
-
-class ToolRegistryClient:
-    """Client-side registry that calls Memra API for tool execution"""
-    
-    def __init__(self):
-        self.api_base = os.getenv("MEMRA_API_URL", "https://api.memra.co")
-        self.api_key = os.getenv("MEMRA_API_KEY")
-        if not self.api_key:
-            raise ValueError(
-                "MEMRA_API_KEY environment variable is required. "
-                "Contact info@memra.co to request access."
-            )
-        self.tools_cache = None
-    
-    def discover_tools(self, hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
-        """Discover available tools from the API"""
-        try:
-            # Use sync httpx for compatibility with existing sync code
-            with httpx.Client(timeout=30.0) as client:
-                response = client.get(
-                    f"{self.api_base}/tools/discover",
-                    headers={"X-API-Key": self.api_key}
-                )
-                response.raise_for_status()
-                
-                data = response.json()
-                tools = data.get("tools", [])
-                
-                # Filter by hosted_by if specified
-                if hosted_by:
-                    tools = [t for t in tools if t.get("hosted_by") == hosted_by]
-                
-                self.tools_cache = tools
-                logger.info(f"Discovered {len(tools)} tools from API")
-                return tools
-                
-        except Exception as e:
-            logger.error(f"Failed to discover tools from API: {e}")
-            # Return empty list if API is unavailable
-            return []
-    
-    def execute_tool(self, tool_name: str, hosted_by: str, input_data: Dict[str, Any], 
-                    config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Execute a tool via the API"""
-        try:
-            logger.info(f"Executing tool {tool_name} via API")
-            
-            # Prepare request payload
-            payload = {
-                "tool_name": tool_name,
-                "hosted_by": hosted_by,
-                "input_data": input_data,
-                "config": config
-            }
-            
-            # Make API call
-            with httpx.Client(timeout=120.0) as client:  # Longer timeout for tool execution
-                response = client.post(
-                    f"{self.api_base}/tools/execute",
-                    headers={
-                        "X-API-Key": self.api_key,
-                        "Content-Type": "application/json"
-                    },
-                    json=payload
-                )
-                response.raise_for_status()
-                
-                result = response.json()
-                logger.info(f"Tool {tool_name} executed successfully via API")
-                return result
-                
-        except httpx.TimeoutException:
-            logger.error(f"Tool {tool_name} execution timed out")
-            return {
-                "success": False,
-                "error": f"Tool execution timed out after 120 seconds"
-            }
-        except httpx.HTTPStatusError as e:
-            logger.error(f"API error for tool {tool_name}: {e.response.status_code}")
-            return {
-                "success": False,
-                "error": f"API error: {e.response.status_code} - {e.response.text}"
-            }
-        except Exception as e:
-            logger.error(f"Tool execution failed for {tool_name}: {str(e)}")
-            return {
-                "success": False,
-                "error": str(e)
-            }
-    
-    def health_check(self) -> bool:
-        """Check if the API is available"""
-        try:
-            with httpx.Client(timeout=10.0) as client:
-                response = client.get(f"{self.api_base}/health")
-                return response.status_code == 200
-        except:
-            return False