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

memra/__init__.py

@@ -1,28 +1,27 @@
 """
-Memra SDK - A declarative orchestration framework for AI-powered business workflows
+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.
 """
 
-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.1"
+
+# Core imports
+from .models import Agent, Department, 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"
-] 
+    "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/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

@@ -2,7 +2,7 @@ import time
 import logging
 from typing import Dict, Any, List, Optional
 from .models import Department, Agent, DepartmentResult, ExecutionTrace, DepartmentAudit
-from .tool_registry_client import ToolRegistryClient
+from .tool_registry import ToolRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -10,7 +10,7 @@ class ExecutionEngine:
     """Engine that executes department workflows by coordinating agents and tools"""
     
     def __init__(self):
-        self.tool_registry = ToolRegistryClient()
+        self.tool_registry = ToolRegistry()
         self.last_execution_audit: Optional[DepartmentAudit] = None
     
     def execute_department(self, department: Department, input_data: Dict[str, Any]) -> DepartmentResult:

memra/tool_registry.py

@@ -0,0 +1,70 @@
+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 via API calls only"""
+    
+    def __init__(self):
+        self.tools: Dict[str, Dict[str, Any]] = {}
+        self._register_known_tools()
+    
+    def _register_known_tools(self):
+        """Register known tools with their metadata (no actual implementations)"""
+        # Server-hosted tools (executed via Memra API)
+        server_tools = [
+            ("DatabaseQueryTool", "Query database schemas and data"),
+            ("PDFProcessor", "Process PDF files and extract content"),
+            ("OCRTool", "Perform OCR on images and documents"),
+            ("InvoiceExtractionWorkflow", "Extract structured data from invoices"),
+            ("FileReader", "Read files from the filesystem"),
+        ]
+        
+        for tool_name, description in server_tools:
+            self.register_tool(tool_name, None, "memra", description)
+        
+        # MCP-hosted tools (executed via MCP bridge)
+        mcp_tools = [
+            ("DataValidator", "Validate data against schemas"),
+            ("PostgresInsert", "Insert data into PostgreSQL database"),
+        ]
+        
+        for tool_name, description in mcp_tools:
+            self.register_tool(tool_name, None, "mcp", description)
+        
+        logger.info(f"Registered {len(self.tools)} tool definitions")
+    
+    def register_tool(self, name: str, tool_class: Optional[type], hosted_by: str, description: str):
+        """Register a tool in the registry (metadata only)"""
+        self.tools[name] = {
+            "class": tool_class,  # Will be None for API-based tools
+            "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 - this should not be called directly in API-based mode"""
+        logger.warning(f"Direct tool execution attempted for {tool_name}. Use API client instead.")
+        return {
+            "success": False,
+            "error": "Direct tool execution not supported. Use API client for tool execution."
+        } 

memra/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.1.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.1
+Name: memra
+Version: 0.2.1
+Summary: Declarative framework for enterprise workflows with MCP integration - Client SDK
+Home-page: https://github.com/memra/memra-sdk
+Author: Memra
+Author-email: Memra <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
+```
+
+## 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
+```

memra-0.2.1.dist-info/RECORD

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

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

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

memra-0.2.1.dist-info/entry_points.txt

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

memra-0.1.2.dist-info/METADATA

@@ -1,191 +0,0 @@
-Metadata-Version: 2.4
-Name: memra
-Version: 0.1.2
-Summary: A declarative orchestration framework for AI-powered business workflows
-Author-email: Memra Team <info@memra.co>
-License: MIT
-Project-URL: Homepage, https://memra.co
-Project-URL: Repository, https://github.com/memra-platform/memra-sdk
-Project-URL: Documentation, https://memra.co
-Project-URL: Bug Reports, https://github.com/memra-platform/memra-sdk/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-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
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: httpx>=0.24.0
-Requires-Dist: typing-extensions>=4.0.0
-Dynamic: license-file
-
-# 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.
-
-## 🚀 Quick Start
-
-```python
-from memra import Agent, Department, LLM
-from memra.execution import ExecutionEngine
-
-# Define your agents declaratively
-data_engineer = Agent(
-    role="Data Engineer",
-    job="Extract invoice schema from database",
-    llm=LLM(model="llama-3.2-11b-vision-preview", temperature=0.1),
-    tools=[
-        {"name": "DatabaseQueryTool", "hosted_by": "memra"}
-    ],
-    output_key="invoice_schema"
-)
-
-invoice_parser = Agent(
-    role="Invoice Parser", 
-    job="Extract structured data from invoice PDF",
-    llm=LLM(model="llama-3.2-11b-vision-preview", temperature=0.0),
-    tools=[
-        {"name": "PDFProcessor", "hosted_by": "memra"},
-        {"name": "InvoiceExtractionWorkflow", "hosted_by": "memra"}
-    ],
-    input_keys=["file", "invoice_schema"],
-    output_key="invoice_data"
-)
-
-# Create a department
-ap_department = Department(
-    name="Accounts Payable",
-    mission="Process invoices accurately into financial system",
-    agents=[data_engineer, invoice_parser],
-    workflow_order=["Data Engineer", "Invoice Parser"]
-)
-
-# Execute the workflow
-engine = ExecutionEngine()
-result = engine.execute_department(ap_department, {
-    "file": "invoice.pdf",
-    "connection": "postgresql://user@host/db"
-})
-
-if result.success:
-    print("✅ Invoice processed successfully!")
-    print(f"Data: {result.data}")
-```
-
-## 📦 Installation
-
-```bash
-pip install memra-sdk
-```
-
-## 🔑 Configuration
-
-### Step 1: Get Your API Key
-Contact **info@memra.co** to request an API key for early access.
-
-### Step 2: Set Your API Key
-Once you receive your API key, configure it:
-
-```bash
-export MEMRA_API_KEY="your-api-key-here"
-export MEMRA_API_URL="https://api.memra.co"  # Optional, defaults to production
-```
-
-Or in Python:
-
-```python
-import os
-os.environ["MEMRA_API_KEY"] = "your-api-key-here"
-```
-
-## 🎯 Key Features
-
-- **Declarative**: Define workflows like Kubernetes YAML
-- **AI-Powered**: Built-in LLM integrations for document processing
-- **Conversational**: Agents explain what they're doing in real-time
-- **Production Ready**: Real database connectivity and file processing
-- **Scalable**: Tools execute on Memra's cloud infrastructure
-
-## 🏗️ Core Concepts
-
-### Agents
-Agents are the workers in your workflow. Each agent has:
-- **Role**: What they do (e.g., "Data Engineer")
-- **Job**: Their specific responsibility
-- **Tools**: What capabilities they use
-- **LLM**: Their AI model configuration
-
-### Departments
-Departments coordinate multiple agents:
-- **Mission**: Overall goal
-- **Workflow Order**: Sequence of agent execution
-- **Manager**: Optional oversight and validation
-
-### Tools
-Tools are hosted capabilities:
-- **memra**: Hosted by Memra (PDF processing, LLMs, databases)
-- **mcp**: Customer-hosted via Model Context Protocol
-
-## 📊 Example Output
-
-```
-🏢 Starting Accounts Payable Department
-📋 Mission: Process invoices accurately into financial system
-👥 Team: Data Engineer, Invoice Parser
-🔄 Workflow: Data Engineer → Invoice Parser
-
-👤 Data Engineer: Hi! I'm starting my work now...
-💭 Data Engineer: My job is to extract invoice schema from database
-⚡ Data Engineer: Using tool 1/1: DatabaseQueryTool
-✅ Data Engineer: Great! DatabaseQueryTool did real work and gave me useful results
-🎉 Data Engineer: Perfect! I completed my work with real data processing
-
-👤 Invoice Parser: Hi! I'm starting my work now...
-💭 Invoice Parser: My job is to extract structured data from invoice pdf
-⚡ Invoice Parser: Using tool 1/2: PDFProcessor
-✅ Invoice Parser: Great! PDFProcessor did real work and gave me useful results
-```
-
-## 🔍 Tool Discovery
-
-Discover available tools:
-
-```python
-from memra import discover_tools, get_api_status
-
-# Check API health
-status = get_api_status()
-print(f"API Health: {status['api_healthy']}")
-print(f"Tools Available: {status['tools_available']}")
-
-# Discover tools
-tools = discover_tools()
-for tool in tools:
-    print(f"- {tool['name']}: {tool['description']}")
-```
-
-## 📚 Examples
-
-See the `examples/` directory for complete workflows:
-
-- `accounts_payable_client.py`: Invoice processing with database integration
-- More examples coming soon!
-
-## 🆘 Support
-
-- **Support**: info@memra.co
-
-## 📄 License
-
-MIT License - see LICENSE file for details.
-
----
-
-**Built with ❤️ by the Memra team** 
-**Note**: The SDK will not work without a valid API key.

memra-0.1.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-memra/__init__.py,sha256=QRk72YETLgL15GVt26tN_rBraCQkhZO7UB9T6d4u_uU,543
-memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
-memra/execution.py,sha256=UJ_MJ4getuSk4HJW1sCi7lc26avX-G6-GxnvE-DiSwk,20191
-memra/models.py,sha256=nTaYLAp0tRzQ0CQaBLNBURfhBQ5_gyty0ams4mghyIc,3289
-memra/tool_registry_client.py,sha256=KyNNxj84248E-8MoWNj6pJmlllUG8s0lmeXXmbu0U7o,3996
-memra-0.1.2.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-memra-0.1.2.dist-info/METADATA,sha256=gHIEJFsMqK7Bc-sIUgZ1LQS5tP3djey0_B3sZVWYINc,5640
-memra-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-memra-0.1.2.dist-info/top_level.txt,sha256=pXWcTRS1zctdiSUivW4iyKpJ4tcfIu-1BW_fpbal3OY,6
-memra-0.1.2.dist-info/RECORD,,