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

memra/__init__.py

@@ -1,28 +1,24 @@
 """
-Memra SDK - A declarative orchestration framework for AI-powered business workflows
+Memra SDK - Declarative framework for enterprise workflows with MCP integration
+
+A powerful orchestration framework that allows you to build AI-powered business workflows
+with hybrid cloud/local execution capabilities.
 """
 
-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.2.0"
+__author__ = "Memra"
+__email__ = "info@memra.co"
+
+# Core imports
+from .models import Agent, Department, LLM, Tool
+from .execution import ExecutionEngine
 
-__version__ = "0.1.2"
+# Make key classes available at package level
 __all__ = [
-    "Agent", 
+    "Agent",
     "Department", 
-    "LLM", 
-    "Tool", 
-    "ExecutionPolicy", 
-    "ExecutionTrace", 
-    "DepartmentResult", 
-    "DepartmentAudit",
-    "discover_tools"
+    "LLM",
+    "Tool",
+    "ExecutionEngine",
+    "__version__"
 ] 

memra/discovery.py

@@ -0,0 +1,15 @@
+from typing import List, Dict, Any, Optional
+from .tool_registry import ToolRegistry
+
+def discover_tools(hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
+    """
+    Discover available tools in the Memra platform.
+    
+    Args:
+        hosted_by: Filter tools by host ("memra" or "mcp"). If None, returns all tools.
+    
+    Returns:
+        List of available tools with their metadata
+    """
+    registry = ToolRegistry()
+    return registry.discover_tools(hosted_by) 

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_client import ToolRegistryClient
 
 logger = logging.getLogger(__name__)
 
@@ -10,7 +10,16 @@ class ExecutionEngine:
     """Engine that executes department workflows by coordinating agents and tools"""
     
     def __init__(self):
-        self.tool_registry = ToolRegistryClient()
+        # 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.last_execution_audit: Optional[DepartmentAudit] = None
     
     def execute_department(self, department: Department, input_data: Dict[str, Any]) -> DepartmentResult:
@@ -194,6 +203,13 @@ 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)
@@ -203,7 +219,7 @@ class ExecutionEngine:
                     tool_name, 
                     hosted_by, 
                     agent_input,
-                    agent.config
+                    tool_config
                 )
                 
                 if not tool_result.get("success", False):

memra/tool_registry.py

@@ -0,0 +1,190 @@
+import importlib
+import logging
+import sys
+import os
+from typing import Dict, Any, List, Optional, Callable
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class ToolRegistry:
+    """Registry for managing and executing tools"""
+    
+    def __init__(self):
+        self.tools: Dict[str, Dict[str, Any]] = {}
+        self._add_project_to_path()
+        self._load_builtin_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
+        
+        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}")
+    
+    def register_tool(self, name: str, tool_class: type, hosted_by: str, description: str):
+        """Register a tool in the registry"""
+        self.tools[name] = {
+            "class": tool_class,
+            "hosted_by": hosted_by,
+            "description": description
+        }
+        logger.debug(f"Registered tool: {name} (hosted by {hosted_by})")
+    
+    def discover_tools(self, hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Discover available tools, optionally filtered by host"""
+        tools = []
+        for name, info in self.tools.items():
+            if hosted_by is None or info["hosted_by"] == hosted_by:
+                tools.append({
+                    "name": name,
+                    "hosted_by": info["hosted_by"],
+                    "description": info["description"]
+                })
+        return tools
+    
+    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} 

memra/tool_registry_client.py

@@ -12,12 +12,13 @@ class ToolRegistryClient:
     def __init__(self):
         self.api_base = os.getenv("MEMRA_API_URL", "https://api.memra.co")
         self.api_key = os.getenv("MEMRA_API_KEY")
+        self.tools_cache = None
+        
         if not self.api_key:
             raise ValueError(
                 "MEMRA_API_KEY environment variable is required. "
-                "Contact info@memra.co to request access."
+                "Please contact info@memra.co for an API key."
             )
-        self.tools_cache = None
     
     def discover_tools(self, hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
         """Discover available tools from the API"""

memra-0.2.0.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: memra
+Version: 0.2.0
+Summary: Declarative framework for enterprise workflows with MCP integration
+Home-page: https://github.com/memra/memra-sdk
+Author: Memra
+Author-email: Memra <info@memra.co>
+License: MIT
+Project-URL: Homepage, https://memra.co
+Project-URL: Repository, https://github.com/memra-platform/memra-sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=1.8.0
+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
+
+# Memra SDK
+
+A declarative orchestration framework for AI-powered business workflows. Think of it as "Kubernetes for business logic" where agents are the pods and departments are the deployments.
+
+## 🚀 Team Setup
+
+**New team member?** See the complete setup guide: **[TEAM_SETUP.md](TEAM_SETUP.md)**
+
+This includes:
+- Database setup (PostgreSQL + Docker)
+- Local development environment
+- Testing instructions
+- Troubleshooting guide
+
+## Quick Start
+
+```python
+from memra.sdk.models import Agent, Department, Tool
+
+# Define your agents
+data_extractor = Agent(
+    role="Data Extraction Specialist",
+    job="Extract and validate data",
+    tools=[Tool(name="DataExtractor", hosted_by="memra")],
+    input_keys=["input_data"],
+    output_key="extracted_data"
+)
+
+# Create a department
+dept = Department(
+    name="Data Processing",
+    mission="Process and validate data",
+    agents=[data_extractor]
+)
+
+# Run the workflow
+result = dept.run({"input_data": {...}})
+```
+
+## Installation
+
+```bash
+pip install memra
+```
+
+## API Access
+
+Memra requires an API key to execute workflows on the hosted infrastructure.
+
+### Get Your API Key
+Contact [info@memra.co](mailto:info@memra.co) for API access.
+
+### Set Your API Key
+```bash
+# Set environment variable
+export MEMRA_API_KEY="your-api-key-here"
+
+# Or add to your shell profile for persistence
+echo 'export MEMRA_API_KEY="your-api-key-here"' >> ~/.zshrc
+```
+
+### Test Your Setup
+```bash
+python examples/accounts_payable_client.py
+```
+
+## Documentation
+
+Documentation is coming soon. For now, see the examples below and in the `examples/` directory.
+
+## Example: Propane Delivery Workflow
+
+See the `examples/propane_delivery.py` file for a complete example of how to use Memra to orchestrate a propane delivery workflow.
+
+## Contributing
+
+We welcome contributions! Please see our [contributing guide](CONTRIBUTING.md) for details.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Examples
+
+```
+├── examples/
+│   ├── accounts_payable_client.py  # API-based example
+│   ├── accounts_payable.py         # Local example
+│   ├── invoice_processing.py       # Simple workflow
+│   └── propane_delivery.py         # Domain example
+├── memra/                  # Core SDK
+├── logic/                  # Tool implementations  
+├── 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.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+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/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+memra = memra.cli:main

memra-0.2.0.dist-info/top_level.txt

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