memra 0.2.0__tar.gz → 0.2.2__tar.gz

memra-0.2.2/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+All notable changes to the Memra SDK will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.2] - 2025-05-28
+
+### Fixed
+- **MCP Integration**: Fixed broken MCP tool execution after repository separation
+- **Tool Registry**: Updated MCP tool routing to use correct endpoints
+- **Bridge Server**: Added working MCP bridge server implementation
+- **Real Work Detection**: Improved detection of real vs mock work for MCP tools
+
+### Added
+- Complete MCP bridge server with DataValidator and PostgresInsert tools
+- Health check endpoint for MCP bridge monitoring
+- Better error handling and fallback for MCP tool execution
+
+### Changed
+- MCP tools now perform real database operations instead of mock responses
+- Improved logging and debugging for MCP tool execution flow
+
+## [0.2.1] - 2025-05-27
+
+## [0.2.0] - 2024-01-17
+
+### Added
+- **MCP (Model Context Protocol) Integration**: Execute operations on local infrastructure while leveraging cloud AI processing
+  - New `mcp_bridge_server.py` for local resource bridging
+  - HMAC authentication for secure cloud-to-local communication
+  - Support for `hosted_by: "mcp"` in agent tool configurations
+  - PostgreSQL integration via MCP bridge
+  - Tool-level configuration support in execution engine
+  - New MCP tools: `PostgresInsert`, `DataValidator`
+
+### Enhanced
+- **Execution Engine**: Updated to support tool-level configuration and MCP routing
+- **Tool Registry Client**: Enhanced API client with better error handling and MCP support
+- **Agent Configuration**: Added support for tool-specific configuration alongside agent-level config
+
+### Examples
+- `examples/accounts_payable_mcp.py` - Complete invoice processing with MCP database integration
+- `test_mcp_success.py` - Simple MCP integration test
+
+### Documentation
+- `docs/mcp_integration.md` - Comprehensive MCP integration guide
+- Updated README with MCP overview and quick start
+
+### Dependencies
+- Added `aiohttp>=3.8.0` for MCP bridge server
+- Added `aiohttp-cors>=0.7.0` for CORS support
+- Added `psycopg2-binary>=2.9.0` for PostgreSQL integration
+
+## [0.1.0] - 2024-01-01
+
+### Added
+- Initial release of Memra SDK
+- Core agent and department framework
+- API client for Memra cloud services
+- Basic tool registry and execution engine
+- Examples for accounts payable and propane delivery workflows 

memra-0.2.2/MANIFEST.in

@@ -0,0 +1,32 @@
+# Include only the client SDK files
+include README.md
+include LICENSE
+include CHANGELOG.md
+include requirements.txt
+include examples/*.py
+include docs/*.md
+include docs/*.sql
+include mcp_bridge_server.py
+recursive-include memra *.py
+
+# Explicitly exclude server-only files and directories
+exclude app.py
+exclude server_tool_registry.py
+exclude config.py
+exclude fly.toml
+exclude Dockerfile
+exclude Procfile
+exclude docker-compose.yml
+recursive-exclude logic *
+recursive-exclude scripts *
+recursive-exclude docs *
+recursive-exclude examples *
+recursive-exclude tests *
+recursive-exclude temp_processing *
+recursive-exclude invoices *
+recursive-exclude local *
+recursive-exclude dist *
+recursive-exclude __pycache__ *
+recursive-exclude *.egg-info *
+exclude .DS_Store
+exclude .dockerignore 

{memra-0.2.0/memra.egg-info → memra-0.2.2}/PKG-INFO

@@ -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.2
+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
 
@@ -102,6 +99,16 @@ echo 'export MEMRA_API_KEY="your-api-key-here"' >> ~/.zshrc
 python examples/accounts_payable_client.py
 ```
 
+## Architecture
+
+The Memra platform consists of three main components:
+
+- **Memra SDK** (this repository): Client library for building and executing workflows
+- **Memra Server**: Hosted infrastructure for heavy AI processing tools
+- **MCP Bridge**: Local execution environment for database operations
+
+Tools are automatically routed between server and local execution based on their `hosted_by` configuration.
+
 ## Documentation
 
 Documentation is coming soon. For now, see the examples below and in the `examples/` directory.
@@ -118,44 +125,24 @@ We welcome contributions! Please see our [contributing guide](CONTRIBUTING.md) f
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-## Examples
+## Repository Structure
 
 ```
-├── 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"
-        }
-    }]
-)
+├── examples/                       # Example workflows and use cases
+│   ├── accounts_payable_client.py  # API-based accounts payable workflow
+│   ├── accounts_payable_mcp.py     # MCP-enabled accounts payable workflow
+│   ├── invoice_processing.py       # Simple invoice processing example
+│   └── propane_delivery.py         # Propane delivery domain example
+├── memra/                          # Core SDK package
+│   ├── __init__.py                 # Package initialization
+│   ├── tool_registry.py            # Tool discovery and routing
+│   └── sdk/                        # SDK components
+│       ├── __init__.py
+│       ├── client.py               # API client
+│       ├── execution_engine.py     # Workflow execution
+│       └── models.py               # Core data models
+├── docs/                           # Documentation
+├── tests/                          # Test suite
+├── local/dependencies/             # Local development setup
+└── scripts/                        # Utility scripts
 ```
-
-📖 **[Complete MCP Integration Guide →](docs/mcp_integration.md)**

{memra-0.2.0 → memra-0.2.2}/README.md

@@ -64,6 +64,16 @@ echo 'export MEMRA_API_KEY="your-api-key-here"' >> ~/.zshrc
 python examples/accounts_payable_client.py
 ```
 
+## Architecture
+
+The Memra platform consists of three main components:
+
+- **Memra SDK** (this repository): Client library for building and executing workflows
+- **Memra Server**: Hosted infrastructure for heavy AI processing tools
+- **MCP Bridge**: Local execution environment for database operations
+
+Tools are automatically routed between server and local execution based on their `hosted_by` configuration.
+
 ## Documentation
 
 Documentation is coming soon. For now, see the examples below and in the `examples/` directory.
@@ -80,44 +90,24 @@ We welcome contributions! Please see our [contributing guide](CONTRIBUTING.md) f
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-## Examples
+## Repository Structure
 
 ```
-├── 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"
-        }
-    }]
-)
+├── examples/                       # Example workflows and use cases
+│   ├── accounts_payable_client.py  # API-based accounts payable workflow
+│   ├── accounts_payable_mcp.py     # MCP-enabled accounts payable workflow
+│   ├── invoice_processing.py       # Simple invoice processing example
+│   └── propane_delivery.py         # Propane delivery domain example
+├── memra/                          # Core SDK package
+│   ├── __init__.py                 # Package initialization
+│   ├── tool_registry.py            # Tool discovery and routing
+│   └── sdk/                        # SDK components
+│       ├── __init__.py
+│       ├── client.py               # API client
+│       ├── execution_engine.py     # Workflow execution
+│       └── models.py               # Core data models
+├── docs/                           # Documentation
+├── tests/                          # Test suite
+├── local/dependencies/             # Local development setup
+└── scripts/                        # Utility scripts
 ```
-
-📖 **[Complete MCP Integration Guide →](docs/mcp_integration.md)**

memra-0.2.2/mcp_bridge_server.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Simple MCP Bridge Server for local tool execution
+"""
+
+import os
+import json
+import hmac
+import hashlib
+import logging
+import asyncio
+import psycopg2
+from aiohttp import web, web_request
+from typing import Dict, Any, Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class MCPBridgeServer:
+    def __init__(self, postgres_url: str, bridge_secret: str):
+        self.postgres_url = postgres_url
+        self.bridge_secret = bridge_secret
+        
+    def verify_signature(self, request_body: str, signature: str) -> bool:
+        """Verify HMAC signature"""
+        expected = hmac.new(
+            self.bridge_secret.encode(),
+            request_body.encode(),
+            hashlib.sha256
+        ).hexdigest()
+        return hmac.compare_digest(expected, signature)
+    
+    async def execute_tool(self, request: web_request.Request) -> web.Response:
+        """Execute MCP tool endpoint"""
+        try:
+            # Get request body
+            body = await request.text()
+            data = json.loads(body)
+            
+            # Verify signature
+            signature = request.headers.get('X-Bridge-Secret')
+            if not signature or signature != self.bridge_secret:
+                logger.warning("Invalid or missing bridge secret")
+                return web.json_response({
+                    "success": False,
+                    "error": "Invalid authentication"
+                }, status=401)
+            
+            tool_name = data.get('tool_name')
+            input_data = data.get('input_data', {})
+            
+            logger.info(f"Executing MCP tool: {tool_name}")
+            
+            if tool_name == "DataValidator":
+                result = await self.data_validator(input_data)
+            elif tool_name == "PostgresInsert":
+                result = await self.postgres_insert(input_data)
+            else:
+                return web.json_response({
+                    "success": False,
+                    "error": f"Unknown tool: {tool_name}"
+                }, status=400)
+            
+            return web.json_response(result)
+            
+        except Exception as e:
+            logger.error(f"Tool execution failed: {str(e)}")
+            return web.json_response({
+                "success": False,
+                "error": str(e)
+            }, status=500)
+    
+    async def data_validator(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate data against schema"""
+        try:
+            invoice_data = input_data.get('invoice_data', {})
+            
+            # Perform basic validation
+            validation_errors = []
+            
+            # Check required fields
+            required_fields = ['headerSection', 'billingDetails', 'chargesSummary']
+            for field in required_fields:
+                if field not in invoice_data:
+                    validation_errors.append(f"Missing required field: {field}")
+            
+            # Validate header section
+            if 'headerSection' in invoice_data:
+                header = invoice_data['headerSection']
+                if not header.get('vendorName'):
+                    validation_errors.append("Missing vendor name in header")
+                if not header.get('subtotal'):
+                    validation_errors.append("Missing subtotal in header")
+            
+            # Validate billing details
+            if 'billingDetails' in invoice_data:
+                billing = invoice_data['billingDetails']
+                if not billing.get('invoiceNumber'):
+                    validation_errors.append("Missing invoice number")
+                if not billing.get('invoiceDate'):
+                    validation_errors.append("Missing invoice date")
+            
+            is_valid = len(validation_errors) == 0
+            
+            logger.info(f"Data validation completed: {'valid' if is_valid else 'invalid'}")
+            
+            return {
+                "success": True,
+                "data": {
+                    "is_valid": is_valid,
+                    "validation_errors": validation_errors,
+                    "validated_data": invoice_data
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Data validation failed: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    async def postgres_insert(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Insert data into PostgreSQL"""
+        try:
+            invoice_data = input_data.get('invoice_data', {})
+            table_name = input_data.get('table_name', 'invoices')
+            
+            # Extract key fields from invoice data
+            header = invoice_data.get('headerSection', {})
+            billing = invoice_data.get('billingDetails', {})
+            charges = invoice_data.get('chargesSummary', {})
+            
+            # Prepare insert data
+            insert_data = {
+                'invoice_number': billing.get('invoiceNumber', ''),
+                'vendor_name': header.get('vendorName', ''),
+                'invoice_date': billing.get('invoiceDate', ''),
+                'total_amount': charges.get('document_total', 0),
+                'tax_amount': charges.get('secondary_tax', 0),
+                'line_items': json.dumps(charges.get('lineItemsBreakdown', [])),
+                'status': 'processed'
+            }
+            
+            # Connect to database and insert
+            conn = psycopg2.connect(self.postgres_url)
+            cursor = conn.cursor()
+            
+            # Build insert query
+            columns = ', '.join(insert_data.keys())
+            placeholders = ', '.join(['%s'] * len(insert_data))
+            query = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders}) RETURNING id"
+            
+            cursor.execute(query, list(insert_data.values()))
+            record_id = cursor.fetchone()[0]
+            
+            conn.commit()
+            cursor.close()
+            conn.close()
+            
+            logger.info(f"Successfully inserted record with ID: {record_id}")
+            
+            return {
+                "success": True,
+                "data": {
+                    "success": True,
+                    "record_id": record_id,
+                    "database_table": table_name,
+                    "inserted_data": insert_data
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Database insert failed: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    async def health_check(self, request: web_request.Request) -> web.Response:
+        """Health check endpoint"""
+        return web.json_response({"status": "healthy", "service": "mcp-bridge"})
+    
+    def create_app(self) -> web.Application:
+        """Create aiohttp application"""
+        app = web.Application()
+        
+        # Add routes
+        app.router.add_post('/execute_tool', self.execute_tool)
+        app.router.add_get('/health', self.health_check)
+        
+        return app
+    
+    async def start(self, port: int = 8081):
+        """Start the server"""
+        app = self.create_app()
+        runner = web.AppRunner(app)
+        await runner.setup()
+        
+        site = web.TCPSite(runner, 'localhost', port)
+        await site.start()
+        
+        logger.info(f"MCP Bridge Server started on http://localhost:{port}")
+        logger.info(f"Available endpoints:")
+        logger.info(f"  POST /execute_tool - Execute MCP tools")
+        logger.info(f"  GET  /health - Health check")
+        
+        # Keep running
+        try:
+            await asyncio.Future()  # Run forever
+        except KeyboardInterrupt:
+            logger.info("Shutting down server...")
+        finally:
+            await runner.cleanup()
+
+def main():
+    # Get configuration from environment
+    postgres_url = os.getenv('MCP_POSTGRES_URL', 'postgresql://tarpus@localhost:5432/memra_invoice_db')
+    bridge_secret = os.getenv('MCP_BRIDGE_SECRET', 'test-secret-for-development')
+    
+    logger.info(f"Starting MCP Bridge Server...")
+    logger.info(f"PostgreSQL URL: {postgres_url}")
+    logger.info(f"Bridge Secret: {'*' * len(bridge_secret)}")
+    
+    # Create and start server
+    server = MCPBridgeServer(postgres_url, bridge_secret)
+    asyncio.run(server.start())
+
+if __name__ == '__main__':
+    main() 

memra-0.2.2/memra/__init__.py

@@ -0,0 +1,27 @@
+"""
+Memra SDK - Declarative AI Workflows
+
+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.2"
+
+# Core imports
+from .models import Agent, Department, Tool
+from .execution import ExecutionEngine
+
+# Make key classes available at package level
+__all__ = [
+    "Agent",
+    "Department", 
+    "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-0.2.0/memra-sdk-package → memra-0.2.2}/memra/execution.py

@@ -2,6 +2,7 @@ import time
 import logging
 from typing import Dict, Any, List, Optional
 from .models import Department, Agent, DepartmentResult, ExecutionTrace, DepartmentAudit
+from .tool_registry import ToolRegistry
 from .tool_registry_client import ToolRegistryClient
 
 logger = logging.getLogger(__name__)
@@ -10,7 +11,8 @@ class ExecutionEngine:
     """Engine that executes department workflows by coordinating agents and tools"""
     
     def __init__(self):
-        self.tool_registry = ToolRegistryClient()
+        self.tool_registry = ToolRegistry()
+        self.api_client = ToolRegistryClient()
         self.last_execution_audit: Optional[DepartmentAudit] = None
     
     def execute_department(self, department: Department, input_data: Dict[str, Any]) -> DepartmentResult:
@@ -199,12 +201,28 @@ class ExecutionEngine:
                 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
-                )
+                print(f"🔍 {agent.role}: Tool {tool_name} is hosted by: {hosted_by}")
+                if hosted_by == "memra":
+                    # Use API client for server-hosted tools
+                    print(f"🌐 {agent.role}: Using API client for {tool_name}")
+                    config_to_pass = tool_spec.get("config") if isinstance(tool_spec, dict) else tool_spec.config
+                    tool_result = self.api_client.execute_tool(
+                        tool_name, 
+                        hosted_by, 
+                        agent_input,
+                        config_to_pass
+                    )
+                else:
+                    # Use local registry for MCP and other local tools
+                    print(f"🏠 {agent.role}: Using local registry for {tool_name}")
+                    config_to_pass = tool_spec.get("config") if isinstance(tool_spec, dict) else tool_spec.config
+                    print(f"🔧 {agent.role}: Config for {tool_name}: {config_to_pass}")
+                    tool_result = self.tool_registry.execute_tool(
+                        tool_name, 
+                        hosted_by, 
+                        agent_input,
+                        config_to_pass
+                    )
                 
                 if not tool_result.get("success", False):
                     print(f"😟 {agent.role}: Oh no! Tool {tool_name} failed: {tool_result.get('error', 'Unknown error')}")
@@ -292,7 +310,8 @@ class ExecutionEngine:
                 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
+                len(str(tool_data)) > 100 and  # Real validation results are more substantial
+                not tool_data.get("_mock", False)  # Not mock data
             )
         
         elif tool_name == "PostgresInsert":
@@ -302,7 +321,8 @@ class ExecutionEngine:
                 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
+                "database_table" in tool_data and  # Real implementation includes table name
+                not tool_data.get("_mock", False)  # Not mock data
             )
         
         # Default to mock work

{memra-0.2.0/memra-sdk-package → memra-0.2.2}/memra/models.py

@@ -12,6 +12,7 @@ class Tool(BaseModel):
     hosted_by: str = "memra"  # or "mcp" for customer's Model Context Protocol
     description: Optional[str] = None
     parameters: Optional[Dict[str, Any]] = None
+    config: Optional[Dict[str, Any]] = None
 
 class Agent(BaseModel):
     role: str