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

memra-sdk-package/examples/accounts_payable_client.py

@@ -1,207 +0,0 @@
-"""
-Client-side Accounts Payable Example
-This version calls the Memra API hosted on Fly.io instead of running tools locally
-"""
-
-import os
-from memra import Agent, Department, LLM, check_api_health, get_api_status
-from memra.execution import ExecutionEngine
-
-# Set API configuration
-os.environ["MEMRA_API_URL"] = "http://localhost:8080"  # Use local API for testing
-os.environ["MEMRA_API_KEY"] = "dev-key"
-
-# Check API health before starting
-print("🔍 Checking Memra API status...")
-api_status = get_api_status()
-print(f"API Health: {'✅ Healthy' if api_status['api_healthy'] else '❌ Unavailable'}")
-print(f"API URL: {api_status['api_url']}")
-print(f"Tools Available: {api_status['tools_available']}")
-
-if not api_status['api_healthy']:
-    print("❌ Cannot proceed - Memra API is not available")
-    print("Make sure the API server is running on localhost:8080")
-    exit(1)
-
-# Define LLMs (these are just metadata - actual LLM calls happen on the server)
-default_llm = LLM(
-    model="llama-3.2-11b-vision-preview",
-    temperature=0.1,
-    max_tokens=2000
-)
-
-parsing_llm = LLM(
-    model="llama-3.2-11b-vision-preview", 
-    temperature=0.0,
-    max_tokens=4000
-)
-
-manager_llm = LLM(
-    model="llama-3.2-11b-vision-preview",
-    temperature=0.2,
-    max_tokens=1000
-)
-
-# Define agents (same declarative interface as before)
-etl_agent = Agent(
-    role="Data Engineer",
-    job="Extract invoice schema from database",
-    llm=default_llm,
-    sops=[
-        "Connect to database using credentials",
-        "Query information_schema for invoices table", 
-        "Extract column names, types, and constraints",
-        "Return schema as structured JSON"
-    ],
-    systems=["Database"],
-    tools=[
-        {"name": "DatabaseQueryTool", "hosted_by": "memra"}
-    ],
-    output_key="invoice_schema"
-)
-
-parser_agent = Agent(
-    role="Invoice Parser",
-    job="Extract structured data from invoice PDF using schema",
-    llm=parsing_llm,
-    sops=[
-        "Load invoice PDF file",
-        "Convert to high-contrast images if needed", 
-        "Run OCR to extract text",
-        "Use schema to identify and extract fields",
-        "Validate extracted data against schema types",
-        "Return structured invoice data"
-    ],
-    systems=["InvoiceStore"],
-    tools=[
-        {"name": "PDFProcessor", "hosted_by": "memra"},
-        {"name": "OCRTool", "hosted_by": "memra"},
-        {"name": "InvoiceExtractionWorkflow", "hosted_by": "memra"}
-    ],
-    input_keys=["file", "invoice_schema"],
-    output_key="invoice_data"
-)
-
-writer_agent = Agent(
-    role="Data Entry Specialist", 
-    job="Write validated invoice data to database",
-    llm=default_llm,
-    sops=[
-        "Validate invoice data completeness",
-        "Map fields to database columns using schema",
-        "Connect to database",
-        "Insert record into invoices table",
-        "Return confirmation with record ID"
-    ],
-    systems=["Database"],
-    tools=[
-        {"name": "DataValidator", "hosted_by": "memra"},
-        {"name": "PostgresInsert", "hosted_by": "memra"}
-    ],
-    input_keys=["invoice_data", "invoice_schema"],
-    output_key="write_confirmation"
-)
-
-manager_agent = Agent(
-    role="Accounts Payable Manager",
-    job="Coordinate invoice processing pipeline and handle exceptions",
-    llm=manager_llm,
-    sops=[
-        "Check if schema extraction succeeded",
-        "Validate parsed invoice has required fields", 
-        "Ensure invoice total matches line items before DB write",
-        "Handle and log any errors with appropriate escalation"
-    ],
-    allow_delegation=True,
-    output_key="workflow_status"
-)
-
-# Create department
-ap_department = Department(
-    name="Accounts Payable",
-    mission="Process invoices accurately into financial system per company data standards",
-    agents=[etl_agent, parser_agent, writer_agent],
-    manager_agent=manager_agent,
-    workflow_order=["Data Engineer", "Invoice Parser", "Data Entry Specialist"],
-    dependencies=["Database", "InvoiceStore"],
-    execution_policy={
-        "retry_on_fail": True,
-        "max_retries": 2,
-        "halt_on_validation_error": True,
-        "timeout_seconds": 300
-    },
-    context={
-        "company_id": "acme_corp",
-        "fiscal_year": "2024"
-    }
-)
-
-# Execute the department (tools will run on Fly.io)
-print("\n🚀 Starting invoice processing workflow...")
-print("📡 Tools will execute on Memra API server")
-
-engine = ExecutionEngine()
-input_data = {
-    "file": "invoices/10352259310.PDF",
-    "connection": "postgresql://tarpus@localhost:5432/memra_invoice_db"
-}
-
-result = engine.execute_department(ap_department, input_data)
-
-# Display results (same as before)
-if result.success:
-    print("✅ Invoice processing completed successfully!")
-    
-    # Show manager validation results
-    if 'workflow_status' in result.data:
-        manager_report = result.data['workflow_status']
-        print(f"\n🔍 Manager Validation Report:")
-        print(f"Status: {manager_report.get('validation_status', 'unknown')}")
-        print(f"Summary: {manager_report.get('summary', 'No summary available')}")
-        
-        # Show agent performance analysis
-        if 'agent_performance' in manager_report:
-            print(f"\n📊 Agent Performance Analysis:")
-            for agent_role, performance in manager_report['agent_performance'].items():
-                work_quality = performance['work_quality']
-                status_emoji = "✅" if work_quality == "real" else "🔄"
-                print(f"{status_emoji} {agent_role}: {performance['status']}")
-                if performance['tools_real_work']:
-                    print(f"   Real work: {', '.join(performance['tools_real_work'])}")
-                if performance['tools_mock_work']:
-                    print(f"   Mock work: {', '.join(performance['tools_mock_work'])}")
-        
-        # Show workflow analysis
-        if 'workflow_analysis' in manager_report:
-            analysis = manager_report['workflow_analysis']
-            print(f"\n📈 Workflow Analysis:")
-            print(f"Overall Quality: {analysis['overall_quality']}")
-            print(f"Real Work: {analysis['real_work_agents']}/{analysis['total_agents']} agents ({analysis['real_work_percentage']:.1f}%)")
-        
-        # Show recommendations
-        if 'recommendations' in manager_report and manager_report['recommendations']:
-            print(f"\n💡 Recommendations:")
-            for rec in manager_report['recommendations']:
-                print(f"   • {rec}")
-    
-    # Try to get record_id if it exists
-    if result.data and 'write_confirmation' in result.data:
-        confirmation = result.data['write_confirmation']
-        if isinstance(confirmation, dict) and 'record_id' in confirmation:
-            print(f"\n💾 Invoice processed successfully: Record ID {confirmation['record_id']}")
-        else:
-            print(f"\n💾 Write confirmation: {confirmation}")
-    
-    print(f"\n📡 All tools executed remotely on Memra API server")
-    
-else:
-    print(f"❌ Processing failed: {result.error}")
-
-# Show execution trace
-print("\n=== Execution Trace ===")
-print(f"Agents executed: {', '.join(result.trace.agents_executed)}")
-print(f"Tools invoked: {', '.join(result.trace.tools_invoked)}")
-if result.trace.errors:
-    print(f"Errors: {', '.join(result.trace.errors)}")
-
-print(f"\n🌐 API Calls made to: {api_status['api_url']}") 

memra-sdk-package/memra/__init__.py

@@ -1,28 +0,0 @@
-"""
-Memra SDK - A declarative orchestration framework for AI-powered business workflows
-"""
-
-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.1.2"
-__all__ = [
-    "Agent", 
-    "Department", 
-    "LLM", 
-    "Tool", 
-    "ExecutionPolicy", 
-    "ExecutionTrace", 
-    "DepartmentResult", 
-    "DepartmentAudit",
-    "discover_tools"
-] 

memra-sdk-package/memra/discovery_client.py

@@ -1,49 +0,0 @@
-"""
-Client-side tool discovery for Memra SDK
-Queries the Memra API to discover available tools
-"""
-
-from typing import List, Dict, Any, Optional
-from .tool_registry_client import ToolRegistryClient
-
-def discover_tools(hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
-    """
-    Discover available tools from the Memra API
-    
-    Args:
-        hosted_by: Filter tools by hosting provider ("memra" or "mcp")
-        
-    Returns:
-        List of available tools with their descriptions
-    """
-    registry = ToolRegistryClient()
-    return registry.discover_tools(hosted_by)
-
-def check_api_health() -> bool:
-    """
-    Check if the Memra API is available
-    
-    Returns:
-        True if API is healthy, False otherwise
-    """
-    registry = ToolRegistryClient()
-    return registry.health_check()
-
-def get_api_status() -> Dict[str, Any]:
-    """
-    Get detailed API status information
-    
-    Returns:
-        Dictionary with API status details
-    """
-    registry = ToolRegistryClient()
-    
-    is_healthy = registry.health_check()
-    tools = registry.discover_tools() if is_healthy else []
-    
-    return {
-        "api_healthy": is_healthy,
-        "api_url": registry.api_base,
-        "tools_available": len(tools),
-        "tools": tools
-    }