memra 0.2.2__tar.gz → 0.2.3__tar.gz

memra-0.2.3/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: memra
+Version: 0.2.3
+Summary: Declarative framework for enterprise workflows with MCP integration - Client SDK
+Home-page: https://github.com/memra/memra-sdk
+Author: Memra
+Author-email: Memra <support@memra.com>
+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
+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
+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"
+Provides-Extra: mcp
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "mcp"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Memra SDK
+
+The core Memra framework for building AI-powered business workflows.
+
+## Installation
+
+```bash
+pip install memra
+```
+
+## Quick Start
+
+```python
+from memra import Agent, Department, LLM, ExecutionEngine
+
+# Define an agent
+agent = Agent(
+    role="Data Analyst",
+    job="Analyze customer data",
+    llm=LLM(model="llama-3.2-11b-vision-preview"),
+    sops=["Load data", "Perform analysis", "Generate report"],
+    output_key="analysis_result"
+)
+
+# Create a department
+department = Department(
+    name="Analytics",
+    mission="Provide data insights",
+    agents=[agent],
+    workflow_order=["Data Analyst"]
+)
+
+# Execute the workflow
+engine = ExecutionEngine()
+result = engine.execute_department(department, {"data": "customer_data.csv"})
+```
+
+## Core Components
+
+### Agent
+An AI worker that performs specific tasks using LLMs and tools.
+
+### Department
+A team of agents working together to accomplish a mission.
+
+### ExecutionEngine
+Orchestrates the execution of departments and their workflows.
+
+### LLM
+Configuration for language models used by agents.
+
+## Examples
+
+See the `examples/` directory for basic usage examples:
+- `simple_text_to_sql.py` - Basic text-to-SQL conversion
+- `ask_questions.py` - Simple question answering
+
+## Documentation
+
+For detailed documentation, visit [docs.memra.co](https://docs.memra.co)
+
+## License
+
+MIT License - see LICENSE file for details. 

memra-0.2.3/README.md

@@ -0,0 +1,64 @@
+# Memra SDK
+
+The core Memra framework for building AI-powered business workflows.
+
+## Installation
+
+```bash
+pip install memra
+```
+
+## Quick Start
+
+```python
+from memra import Agent, Department, LLM, ExecutionEngine
+
+# Define an agent
+agent = Agent(
+    role="Data Analyst",
+    job="Analyze customer data",
+    llm=LLM(model="llama-3.2-11b-vision-preview"),
+    sops=["Load data", "Perform analysis", "Generate report"],
+    output_key="analysis_result"
+)
+
+# Create a department
+department = Department(
+    name="Analytics",
+    mission="Provide data insights",
+    agents=[agent],
+    workflow_order=["Data Analyst"]
+)
+
+# Execute the workflow
+engine = ExecutionEngine()
+result = engine.execute_department(department, {"data": "customer_data.csv"})
+```
+
+## Core Components
+
+### Agent
+An AI worker that performs specific tasks using LLMs and tools.
+
+### Department
+A team of agents working together to accomplish a mission.
+
+### ExecutionEngine
+Orchestrates the execution of departments and their workflows.
+
+### LLM
+Configuration for language models used by agents.
+
+## Examples
+
+See the `examples/` directory for basic usage examples:
+- `simple_text_to_sql.py` - Basic text-to-SQL conversion
+- `ask_questions.py` - Simple question answering
+
+## Documentation
+
+For detailed documentation, visit [docs.memra.co](https://docs.memra.co)
+
+## License
+
+MIT License - see LICENSE file for details. 

{memra-0.2.2 → memra-0.2.3}/memra/__init__.py

@@ -6,18 +6,22 @@ Think of it as "Kubernetes for business logic" where agents are the pods and
 departments are the deployments.
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 # Core imports
-from .models import Agent, Department, Tool
+from .models import Agent, Department, Tool, LLM
 from .execution import ExecutionEngine
+from .discovery_client import check_api_health, get_api_status
 
 # Make key classes available at package level
 __all__ = [
     "Agent",
     "Department", 
     "Tool",
+    "LLM",
     "ExecutionEngine",
+    "check_api_health",
+    "get_api_status",
     "__version__"
 ]
 

{memra-0.2.2 → memra-0.2.3}/memra/execution.py

@@ -216,6 +216,21 @@ class ExecutionEngine:
                     # 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
+                    
+                    # For MCP tools, merge department context MCP configuration
+                    if hosted_by == "mcp":
+                        mcp_config = {}
+                        dept_context = context.get("department_context", {})
+                        if "mcp_bridge_url" in dept_context:
+                            mcp_config["bridge_url"] = dept_context["mcp_bridge_url"]
+                        if "mcp_bridge_secret" in dept_context:
+                            mcp_config["bridge_secret"] = dept_context["mcp_bridge_secret"]
+                        
+                        # Merge with tool-specific config if it exists
+                        if config_to_pass:
+                            mcp_config.update(config_to_pass)
+                        config_to_pass = mcp_config
+                    
                     print(f"🔧 {agent.role}: Config for {tool_name}: {config_to_pass}")
                     tool_result = self.tool_registry.execute_tool(
                         tool_name, 
@@ -325,6 +340,34 @@ class ExecutionEngine:
                 not tool_data.get("_mock", False)  # Not mock data
             )
         
+        elif tool_name == "FileDiscovery":
+            # Real work if it actually discovered files in a real directory
+            return (
+                "files" in tool_data and
+                isinstance(tool_data["files"], list) and
+                "directory" in tool_data and
+                tool_data.get("success", False) == True
+            )
+            
+        elif tool_name == "FileCopy":
+            # Real work if it actually copied a file
+            return (
+                "destination_path" in tool_data and
+                "source_path" in tool_data and
+                tool_data.get("success", False) == True and
+                tool_data.get("operation") == "copy_completed"
+            )
+        
+        elif tool_name == "TextToSQL":
+            # Real work if it actually executed SQL and returned real results
+            return (
+                "generated_sql" in tool_data and
+                "results" in tool_data and
+                isinstance(tool_data["results"], list) and
+                tool_data.get("success", False) == True and
+                not tool_data.get("_mock", False)  # Not mock data
+            )
+        
         # Default to mock work
         return False
     

{memra-0.2.2 → memra-0.2.3}/memra/tool_registry.py

@@ -24,6 +24,8 @@ class ToolRegistry:
             ("OCRTool", "Perform OCR on images and documents"),
             ("InvoiceExtractionWorkflow", "Extract structured data from invoices"),
             ("FileReader", "Read files from the filesystem"),
+            ("FileDiscovery", "Discover and list files in directories"),
+            ("FileCopy", "Copy files to standard processing directories"),
         ]
         
         for tool_name, description in server_tools:
@@ -33,6 +35,9 @@ class ToolRegistry:
         mcp_tools = [
             ("DataValidator", "Validate data against schemas"),
             ("PostgresInsert", "Insert data into PostgreSQL database"),
+            ("TextToSQL", "Convert natural language questions to SQL queries and execute them"),
+            ("SQLExecutor", "Execute SQL queries against PostgreSQL database"),
+            ("TextToSQLGenerator", "Generate SQL from natural language questions"),
         ]
         
         for tool_name, description in mcp_tools:
@@ -169,6 +174,155 @@ class ToolRegistry:
                         "_mock": True
                     }
                 }
+            elif tool_name == "FileDiscovery":
+                # Mock file discovery - in real implementation, would scan directories
+                directory = input_data.get("directory", "invoices")
+                file_pattern = input_data.get("pattern", "*.pdf")
+                
+                # Simulate finding files in the directory
+                mock_files = [
+                    {
+                        "filename": "10352259310.PDF",
+                        "path": f"{directory}/10352259310.PDF",
+                        "size": "542KB",
+                        "modified": "2024-05-28",
+                        "type": "PDF"
+                    }
+                ]
+                
+                return {
+                    "success": True,
+                    "data": {
+                        "directory": directory,
+                        "pattern": file_pattern,
+                        "files_found": len(mock_files),
+                        "files": mock_files,
+                        "message": f"Found {len(mock_files)} files in {directory}/ directory"
+                    }
+                }
+                
+            elif tool_name == "FileCopy":
+                # Mock file copy - in real implementation, would copy files
+                source_path = input_data.get("source_path", "")
+                destination_dir = input_data.get("destination_dir", "invoices")
+                
+                if not source_path:
+                    return {
+                        "success": False,
+                        "error": "Source path is required"
+                    }
+                
+                # Extract filename from path
+                import os
+                filename = os.path.basename(source_path)
+                destination_path = f"{destination_dir}/{filename}"
+                
+                return {
+                    "success": True,
+                    "data": {
+                        "source_path": source_path,
+                        "destination_path": destination_path,
+                        "message": f"File copied from {source_path} to {destination_path}",
+                        "file_size": "245KB",
+                        "operation": "copy_completed"
+                    }
+                }
+            elif tool_name == "TextToSQL":
+                # Mock text-to-SQL - in real implementation, would use LLM to generate SQL
+                question = input_data.get("question", "")
+                schema = input_data.get("schema", {})
+                
+                if not question:
+                    return {
+                        "success": False,
+                        "error": "Question is required for text-to-SQL conversion"
+                    }
+                
+                # Simulate SQL generation and execution
+                mock_sql = "SELECT vendor_name, invoice_number, total_amount FROM invoices WHERE vendor_name ILIKE '%air liquide%' ORDER BY invoice_date DESC LIMIT 5;"
+                mock_results = [
+                    {
+                        "vendor_name": "Air Liquide Canada Inc.",
+                        "invoice_number": "INV-12345",
+                        "total_amount": 1234.56
+                    },
+                    {
+                        "vendor_name": "Air Liquide Canada Inc.", 
+                        "invoice_number": "INV-67890",
+                        "total_amount": 2345.67
+                    }
+                ]
+                
+                return {
+                    "success": True,
+                    "data": {
+                        "question": question,
+                        "generated_sql": mock_sql,
+                        "results": mock_results,
+                        "row_count": len(mock_results),
+                        "message": f"Found {len(mock_results)} results for: {question}",
+                        "_mock": True
+                    }
+                }
+            elif tool_name == "SQLExecutor":
+                # Mock SQL execution
+                sql_query = input_data.get("sql_query", "")
+                
+                if not sql_query:
+                    return {
+                        "success": False,
+                        "error": "SQL query is required"
+                    }
+                
+                # Mock results based on query type
+                if sql_query.upper().startswith("SELECT"):
+                    mock_results = [
+                        {"vendor_name": "Air Liquide Canada Inc.", "invoice_number": "INV-12345", "total_amount": 1234.56},
+                        {"vendor_name": "Air Liquide Canada Inc.", "invoice_number": "INV-67890", "total_amount": 2345.67}
+                    ]
+                    return {
+                        "success": True,
+                        "data": {
+                            "query": sql_query,
+                            "results": mock_results,
+                            "row_count": len(mock_results),
+                            "columns": ["vendor_name", "invoice_number", "total_amount"],
+                            "_mock": True
+                        }
+                    }
+                else:
+                    return {
+                        "success": True,
+                        "data": {
+                            "query": sql_query,
+                            "affected_rows": 1,
+                            "message": "Query executed successfully",
+                            "_mock": True
+                        }
+                    }
+            elif tool_name == "TextToSQLGenerator":
+                # Mock SQL generation
+                question = input_data.get("question", "")
+                
+                if not question:
+                    return {
+                        "success": False,
+                        "error": "Question is required for SQL generation"
+                    }
+                
+                # Generate mock SQL based on question
+                mock_sql = "SELECT * FROM invoices WHERE vendor_name ILIKE '%air liquide%'"
+                
+                return {
+                    "success": True,
+                    "data": {
+                        "question": question,
+                        "generated_sql": mock_sql,
+                        "explanation": "Generated SQL query based on natural language question",
+                        "confidence": "medium",
+                        "_mock": True
+                    }
+                }
             else:
                 return {
                     "success": False,

{memra-0.2.2 → memra-0.2.3}/memra.egg-info/SOURCES.txt

@@ -1,8 +1,5 @@
-CHANGELOG.md
-LICENSE
 MANIFEST.in
 README.md
-mcp_bridge_server.py
 pyproject.toml
 setup.py
 memra/__init__.py

{memra-0.2.2 → memra-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memra"
-version = "0.2.2"
+version = "0.2.3"
 description = "Declarative framework for enterprise workflows with MCP integration - Client SDK"
 readme = "README.md"
 license = {text = "MIT"}

{memra-0.2.2 → memra-0.2.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="memra",
-    version="0.2.2",
+    version="0.2.3",
     author="Memra",
     author_email="support@memra.com",
     description="Declarative framework for enterprise workflows with MCP integration - Client SDK",

memra-0.2.2/CHANGELOG.md

@@ -1,63 +0,0 @@
-# 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/PKG-INFO

@@ -1,148 +0,0 @@
-Metadata-Version: 2.1
-Name: memra
-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 <support@memra.com>
-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
-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"
-Provides-Extra: mcp
-Requires-Dist: psycopg2-binary>=2.9.0; extra == "mcp"
-
-# 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
-```
-
-## 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.
-
-## 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.
-
-## Repository Structure
-
-```
-├── 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
-```

memra-0.2.2/README.md

@@ -1,113 +0,0 @@
-# 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
-```
-
-## 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.
-
-## 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.
-
-## Repository Structure
-
-```
-├── 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
-```

memra-0.2.2/mcp_bridge_server.py

@@ -1,230 +0,0 @@
-#!/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()