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

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

@@ -0,0 +1,106 @@
+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")
+        self.tools_cache = None
+        
+        if not self.api_key:
+            raise ValueError(
+                "MEMRA_API_KEY environment variable is required. "
+                "Please contact info@memra.co for an API key."
+            )
+    
+    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 

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.0.1.dist-info → memra-0.2.0.dist-info}/WHEEL

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

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