memra 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

memra-workflows/accounts_payable/accounts_payable_smart.py

@@ -1,221 +0,0 @@
-#!/usr/bin/env python3
-"""
-Smart Accounts Payable Example with File Discovery
-This example demonstrates intelligent file discovery and management
-"""
-
-import os
-import sys
-import logging
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from memra import Agent, Department
-from memra.execution import ExecutionEngine
-
-# Set up environment
-os.environ['MEMRA_API_KEY'] = 'memra-prod-2024-001'
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Enhanced agents with smart file discovery
-etl_agent = Agent(
-    role="Data Engineer",
-    job="Extract invoice schema from Postgres database",
-    sops=[
-        "Connect to PostgresDB using credentials",
-        "Query information_schema for invoices table",
-        "Extract column names, types, and constraints",
-        "Return schema as structured JSON"
-    ],
-    systems=["PostgresDB"],
-    tools=[
-        {"name": "DatabaseQueryTool", "hosted_by": "memra"}
-    ],
-    output_key="invoice_schema"
-)
-
-# Smart Invoice Parser with file discovery
-smart_parser_agent = Agent(
-    role="Smart Invoice Parser",
-    job="Extract structured data from invoice PDFs",
-    sops=[
-        "Load and process the 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"],  # file is the correct key
-    output_key="invoice_data"
-)
-
-writer_agent = Agent(
-    role="Data Entry Specialist",
-    job="Write validated invoice data to Postgres database",
-    sops=[
-        "Validate invoice data completeness",
-        "Map fields to database columns using schema",
-        "Connect to PostgresDB",
-        "Insert record into invoices table",
-        "Return confirmation with record ID"
-    ],
-    systems=["PostgresDB"],
-    tools=[
-        {"name": "DataValidator", "hosted_by": "memra"},
-        {"name": "PostgresInsert", "hosted_by": "memra"}
-    ],
-    input_keys=["invoice_data", "invoice_schema"],
-    output_key="write_confirmation"
-)
-
-# Smart manager that handles file discovery workflow
-smart_manager_agent = Agent(
-    role="Smart Accounts Payable Manager",
-    job="Coordinate intelligent invoice processing with file discovery",
-    sops=[
-        "Check if specific file path was provided",
-        "If no file specified, discover available files in invoices/ directory",
-        "Handle file copying from external locations if needed",
-        "Coordinate schema extraction and invoice processing",
-        "Validate results and provide comprehensive reporting"
-    ],
-    allow_delegation=True,
-    output_key="workflow_status"
-)
-
-# Create the smart department
-smart_ap_department = Department(
-    name="Smart Accounts Payable",
-    mission="Intelligently discover and process invoices with minimal user input",
-    agents=[etl_agent, smart_parser_agent, writer_agent],
-    manager_agent=smart_manager_agent,
-    workflow_order=["Data Engineer", "Smart Invoice Parser", "Data Entry Specialist"],
-    dependencies=["PostgresDB", "InvoiceStore", "FileSystem"],
-    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",
-        "default_invoice_dir": "invoices",
-        "mcp_bridge_url": "http://localhost:8081",
-        "mcp_bridge_secret": "test-secret-for-development"
-    }
-)
-
-def main():
-    print("🧠 Smart Accounts Payable with File Discovery")
-    print("=" * 60)
-    
-    # Create execution engine
-    engine = ExecutionEngine()
-    
-    # Example 1: Auto-discovery mode (no file specified)
-    print("\n📂 Example 1: Auto-discovery mode")
-    print("Scanning invoices/ directory for available files...")
-    
-    input_data_auto = {
-        "file": "invoices/10352259310.PDF",  # Default file for auto-discovery demo
-        "connection": "postgresql://tarpus@localhost:5432/memra_invoice_db"
-    }
-    
-    result = engine.execute_department(smart_ap_department, input_data_auto)
-    
-    if result.success:
-        print("✅ Auto-discovery workflow completed successfully!")
-        display_results(result)
-    else:
-        print(f"❌ Auto-discovery failed: {result.error}")
-    
-    print("\n" + "="*60)
-    
-    # Example 2: External file mode
-    print("\n📁 Example 2: External file processing")
-    print("Processing file from external location...")
-    
-    input_data_external = {
-        "file": "invoices/10352259310.PDF",  # Use existing file for demo
-        "connection": "postgresql://tarpus@localhost:5432/memra_invoice_db"
-    }
-    
-    result = engine.execute_department(smart_ap_department, input_data_external)
-    
-    if result.success:
-        print("✅ External file workflow completed successfully!")
-        display_results(result)
-    else:
-        print(f"❌ External file processing failed: {result.error}")
-    
-    print("\n" + "="*60)
-    
-    # Example 3: Specific file mode
-    print("\n🎯 Example 3: Specific file processing")
-    print("Processing specific file from invoices/ directory...")
-    
-    input_data_specific = {
-        "file": "invoices/10352259310.PDF",  # Specific file
-        "connection": "postgresql://tarpus@localhost:5432/memra_invoice_db"
-    }
-    
-    result = engine.execute_department(smart_ap_department, input_data_specific)
-    
-    if result.success:
-        print("✅ Specific file workflow completed successfully!")
-        display_results(result)
-    else:
-        print(f"❌ Specific file processing failed: {result.error}")
-
-def display_results(result):
-    """Display comprehensive workflow results"""
-    
-    # Show manager validation results
-    if 'workflow_status' in result.data:
-        manager_report = result.data['workflow_status']
-        print(f"\n🔍 Manager Report:")
-        print(f"Status: {manager_report.get('validation_status', 'unknown')}")
-        print(f"Summary: {manager_report.get('summary', 'No summary available')}")
-        
-        # Show agent performance
-        if 'agent_performance' in manager_report:
-            print(f"\n📊 Agent Performance:")
-            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'])}")
-    
-    # Show file discovery results
-    if 'invoice_data' in result.data:
-        invoice_data = result.data['invoice_data']
-        if isinstance(invoice_data, dict) and 'file_metadata' in invoice_data:
-            print(f"\n📄 File Processing:")
-            metadata = invoice_data['file_metadata']
-            print(f"Processed: {metadata.get('filename', 'unknown')}")
-            print(f"Location: {metadata.get('path', 'unknown')}")
-            print(f"Size: {metadata.get('size', 'unknown')}")
-    
-    # Show database results
-    if 'write_confirmation' in result.data:
-        confirmation = result.data['write_confirmation']
-        if isinstance(confirmation, dict) and 'record_id' in confirmation:
-            print(f"\n💾 Database: Record ID {confirmation['record_id']}")
-    
-    # Show execution trace
-    print(f"\n🔄 Execution: {', '.join(result.trace.agents_executed)}")
-    print(f"🛠 Tools: {', '.join(result.trace.tools_invoked)}")
-
-if __name__ == "__main__":
-    main() 

memra-workflows/invoice_processing/invoice_processing.py

@@ -1,116 +0,0 @@
-from memra import Agent, Department, LLM
-
-# Define LLMs that agents can use
-default_llm = LLM(model="gpt-4", temperature=0.1)
-parsing_llm = LLM(model="claude-3-opus", temperature=0)  # More accurate for structured extraction
-manager_llm = LLM(model="gpt-4-turbo", temperature=0.3)  # Balanced for decision-making
-
-# Define agents with specific LLMs
-etl_agent = Agent(
-    role="Data Engineer",
-    job="Extract invoice schema from Postgres database",
-    llm=default_llm,  # Standard LLM for SQL generation
-    sops=[
-        "Connect to PostgresDB using credentials",
-        "Query information_schema for invoices table",
-        "Extract column names, types, and constraints",
-        "Return schema as structured JSON"
-    ],
-    systems=["PostgresDB"],
-    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,  # High-accuracy LLM for document parsing
-    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 Postgres database",
-    llm=default_llm,
-    sops=[
-        "Validate invoice data completeness",
-        "Map fields to database columns using schema",
-        "Connect to PostgresDB",
-        "Insert record into invoices table",
-        "Return confirmation with record ID"
-    ],
-    systems=["PostgresDB"],
-    tools=[
-        {"name": "DataValidator", "hosted_by": "memra"},
-        {"name": "PostgresInsert", "hosted_by": "mcp"}
-    ],
-    input_keys=["invoice_data", "invoice_schema"],
-    output_key="write_confirmation"
-)
-
-# Manager with its own LLM
-manager_agent = Agent(
-    role="Accounts Payable Manager",
-    job="Coordinate invoice processing pipeline and handle exceptions",
-    llm=manager_llm,  # Manager gets a more flexible LLM
-    sops=[
-        "Check if schema extraction succeeded",
-        "If schema missing, delegate to Schema Loader",
-        "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,
-    fallback_agents={
-        "Data Engineer": "Schema Loader"
-    },
-    output_key="workflow_status"
-)
-
-# Create the Accounts Payable 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,
-    default_llm=default_llm,  # Fallback for any agent without explicit LLM
-    workflow_order=["Data Engineer", "Invoice Parser", "Data Entry Specialist"]
-)
-
-# Example usage
-if __name__ == "__main__":
-    from memra.execution import ExecutionEngine
-    
-    # This is how a developer would use the department
-    engine = ExecutionEngine()
-    input_data = {
-        "file": "path/to/invoice.pdf",
-        "connection": "postgres://ap_user:password@localhost:5432/finance"
-    }
-    
-    result = engine.execute_department(ap_department, input_data)
-    
-    if result.success:
-        print("✅ Invoice processing completed!")
-        print(f"Result: {result.data}")
-    else:
-        print(f"❌ Processing failed: {result.error}")
-    
-    print(f"Workflow result: {result}") 

memra-workflows/invoice_processing/smart_invoice_processor.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-"""
-Smart Invoice Processor with Intelligent File Discovery
-
-This system automatically:
-1. Empty invoices/ directory → Ask user for file path
-2. Single file in invoices/ → Process it automatically  
-3. Multiple files in invoices/ → Show list, let user choose or batch process
-"""
-
-import os
-import sys
-import glob
-from pathlib import Path
-
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from memra import Agent, Department, ExecutionEngine
-
-# Set up environment
-os.environ['MEMRA_API_KEY'] = 'memra-prod-2024-001'
-
-def discover_invoice_files():
-    """Discover invoice files in the invoices directory"""
-    invoice_dir = Path("invoices")
-    if not invoice_dir.exists():
-        invoice_dir.mkdir()
-        return []
-    
-    # Look for PDF files
-    pdf_files = list(invoice_dir.glob("*.pdf")) + list(invoice_dir.glob("*.PDF"))
-    return [str(f) for f in pdf_files]
-
-def get_file_to_process():
-    """Intelligent file discovery logic"""
-    files = discover_invoice_files()
-    
-    if len(files) == 0:
-        print("📂 The invoices/ directory is empty.")
-        print("Please provide the path to the invoice you want to process:")
-        file_path = input("File path: ").strip()
-        
-        if not file_path:
-            print("❌ No file path provided.")
-            return None
-            
-        if not os.path.exists(file_path):
-            print(f"❌ File not found: {file_path}")
-            return None
-            
-        # Copy file to invoices directory
-        import shutil
-        filename = os.path.basename(file_path)
-        dest_path = f"invoices/{filename}"
-        shutil.copy2(file_path, dest_path)
-        print(f"📁 Copied {filename} to invoices/ directory")
-        return dest_path
-        
-    elif len(files) == 1:
-        print(f"📄 Found 1 invoice file: {files[0]}")
-        print("🚀 Processing automatically...")
-        return files[0]
-        
-    else:
-        print(f"📄 Found {len(files)} invoice files:")
-        for i, file in enumerate(files, 1):
-            filename = os.path.basename(file)
-            size = os.path.getsize(file)
-            size_kb = size // 1024
-            print(f"  {i}. {filename} ({size_kb}KB)")
-        
-        print("\nOptions:")
-        print("  • Enter a number (1-{}) to process that file".format(len(files)))
-        print("  • Enter 'all' to process all files in batch")
-        print("  • Enter 'quit' to exit")
-        
-        choice = input("Your choice: ").strip().lower()
-        
-        if choice == 'quit':
-            return None
-        elif choice == 'all':
-            return 'batch'
-        else:
-            try:
-                index = int(choice) - 1
-                if 0 <= index < len(files):
-                    return files[index]
-                else:
-                    print("❌ Invalid selection")
-                    return None
-            except ValueError:
-                print("❌ Invalid input")
-                return None
-
-def create_invoice_processing_department():
-    """Create the invoice processing department"""
-    
-    # Schema extraction agent
-    schema_agent = Agent(
-        role="Schema Engineer",
-        job="Extract invoice database schema",
-        tools=[
-            {"name": "DatabaseQueryTool", "hosted_by": "memra"}
-        ],
-        output_key="invoice_schema"
-    )
-    
-    # Invoice processing agent
-    processor_agent = Agent(
-        role="Invoice Processor",
-        job="Extract structured data from invoice PDF",
-        tools=[
-            {"name": "PDFProcessor", "hosted_by": "memra"},
-            {"name": "InvoiceExtractionWorkflow", "hosted_by": "memra"}
-        ],
-        input_keys=["file", "invoice_schema"],
-        output_key="invoice_data"
-    )
-    
-    # Database writer agent
-    writer_agent = Agent(
-        role="Database Writer",
-        job="Insert validated invoice data into database",
-        tools=[
-            {"name": "DataValidator", "hosted_by": "mcp"},
-            {"name": "PostgresInsert", "hosted_by": "mcp"}
-        ],
-        input_keys=["invoice_data", "invoice_schema"],
-        output_key="write_confirmation"
-    )
-    
-    return Department(
-        name="Smart Invoice Processing",
-        mission="Intelligently process invoices from PDF to database",
-        agents=[schema_agent, processor_agent, writer_agent],
-        workflow_order=["Schema Engineer", "Invoice Processor", "Database Writer"],
-        context={
-            "mcp_bridge_url": "http://localhost:8081",
-            "mcp_bridge_secret": "test-secret-for-development"
-        }
-    )
-
-def process_single_invoice(file_path):
-    """Process a single invoice file"""
-    print(f"\n🔄 Processing: {os.path.basename(file_path)}")
-    print("=" * 60)
-    
-    department = create_invoice_processing_department()
-    engine = ExecutionEngine()
-    
-    input_data = {
-        "file": file_path,
-        "connection": "postgresql://tarpus@localhost:5432/memra_invoice_db"
-    }
-    
-    result = engine.execute_department(department, input_data)
-    
-    if result.success:
-        print(f"✅ Successfully processed {os.path.basename(file_path)}")
-        
-        # Show extracted data
-        invoice_data = result.data.get('invoice_data', {})
-        if 'headerSection' in invoice_data:
-            vendor = invoice_data['headerSection'].get('vendorName', 'Unknown')
-            print(f"🏢 Vendor: {vendor}")
-        
-        # Show database result
-        confirmation = result.data.get('write_confirmation', {})
-        if 'record_id' in confirmation:
-            print(f"💾 Database Record ID: {confirmation['record_id']}")
-        elif confirmation.get('_mock'):
-            print("🔄 Database: Mock insertion (MCP bridge issue)")
-        
-        return True
-    else:
-        print(f"❌ Failed to process {os.path.basename(file_path)}: {result.error}")
-        return False
-
-def process_batch(file_list):
-    """Process multiple invoice files in batch"""
-    print(f"\n🔄 Batch Processing: {len(file_list)} files")
-    print("=" * 60)
-    
-    results = []
-    for i, file_path in enumerate(file_list, 1):
-        print(f"\n📄 File {i}/{len(file_list)}: {os.path.basename(file_path)}")
-        success = process_single_invoice(file_path)
-        results.append((file_path, success))
-    
-    # Summary
-    print(f"\n📊 Batch Processing Summary:")
-    successful = sum(1 for _, success in results if success)
-    print(f"✅ Successful: {successful}/{len(file_list)}")
-    
-    if successful < len(file_list):
-        print("❌ Failed files:")
-        for file_path, success in results:
-            if not success:
-                print(f"  • {os.path.basename(file_path)}")
-
-def main():
-    print("🧠 Smart Invoice Processor")
-    print("Intelligent file discovery and processing")
-    print("=" * 60)
-    
-    # Discover what to process
-    target = get_file_to_process()
-    
-    if target is None:
-        print("👋 Goodbye!")
-        return
-    
-    if target == 'batch':
-        files = discover_invoice_files()
-        process_batch(files)
-    else:
-        process_single_invoice(target)
-
-if __name__ == "__main__":
-    main() 

memra-workflows/logic/__init__.py

@@ -1 +0,0 @@
-# Logic package - contains the actual implementation of tools and workflows 

memra-workflows/logic/file_tools.py

@@ -1,50 +0,0 @@
-from typing import Dict, Any
-import logging
-import json
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-class FileReader:
-    """Tool for reading files from the filesystem"""
-    
-    def read_file(self, file_path: str) -> Dict[str, Any]:
-        """Read a file and return its contents"""
-        logger.info(f"Reading file: {file_path}")
-        try:
-            path = Path(file_path)
-            if not path.exists():
-                return {
-                    "success": False,
-                    "error": f"File not found: {file_path}"
-                }
-            
-            with open(path, 'r') as f:
-                content = f.read()
-                
-            # Try to parse as JSON if it's a .json file
-            if path.suffix.lower() == '.json':
-                try:
-                    parsed_content = json.loads(content)
-                    return {
-                        "success": True,
-                        "content": parsed_content,
-                        "raw_content": content
-                    }
-                except json.JSONDecodeError as e:
-                    return {
-                        "success": False,
-                        "error": f"Invalid JSON: {str(e)}"
-                    }
-            
-            return {
-                "success": True,
-                "content": content
-            }
-            
-        except Exception as e:
-            logger.error(f"Error reading file {file_path}: {str(e)}")
-            return {
-                "success": False,
-                "error": str(e)
-            }