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

memra-workflows/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() 

memra-workflows/propane_delivery/propane_delivery.py

@@ -1,87 +0,0 @@
-from memra.sdk.models import Agent, Department, Tool
-
-# Define the tools that our agents will use
-data_extraction_tool = Tool(
-    name="PropaneDataExtractor",
-    description="Extracts propane-related data from various sources",
-    hosted_by="memra"
-)
-
-planning_tool = Tool(
-    name="PropaneDeliveryPlanner",
-    description="Plans optimal propane delivery routes and schedules",
-    hosted_by="memra"
-)
-
-execution_tool = Tool(
-    name="PropaneDeliveryExecutor",
-    description="Executes and tracks propane deliveries",
-    hosted_by="memra"
-)
-
-# Define our agents
-data_extractor = Agent(
-    role="Data Extraction Specialist",
-    job="Extract and validate propane delivery data",
-    tools=[data_extraction_tool],
-    systems=["CustomerDatabase", "PropaneLevelsAPI"],
-    input_keys=["customer_ids", "date_range"],
-    output_key="extracted_data"
-)
-
-delivery_planner = Agent(
-    role="Delivery Route Planner",
-    job="Plan optimal delivery routes and schedules",
-    tools=[planning_tool],
-    systems=["RouteOptimizationEngine"],
-    input_keys=["extracted_data"],
-    output_key="delivery_plan"
-)
-
-delivery_executor = Agent(
-    role="Delivery Coordinator",
-    job="Execute and monitor propane deliveries",
-    tools=[execution_tool],
-    systems=["DeliveryTrackingSystem"],
-    input_keys=["delivery_plan"],
-    output_key="delivery_status"
-)
-
-# Define the manager agent that oversees the workflow
-manager = Agent(
-    role="Propane Operations Manager",
-    job="Oversee and coordinate the propane delivery workflow",
-    llm={"model": "claude-3-opus"},
-    sops=[
-        "Validate data quality",
-        "Handle delivery exceptions",
-        "Optimize resource allocation"
-    ],
-    input_keys=["extracted_data", "delivery_plan", "delivery_status"],
-    output_key="workflow_status"
-)
-
-# Create the Propane Delivery Department
-propane_department = Department(
-    name="Propane Delivery Operations",
-    mission="Efficiently manage and execute propane deliveries",
-    agents=[data_extractor, delivery_planner, delivery_executor],
-    manager_agent=manager,
-    workflow_order=[
-        "Data Extraction Specialist",
-        "Delivery Route Planner",
-        "Delivery Coordinator"
-    ]
-)
-
-# Example usage
-if __name__ == "__main__":
-    # This is how a developer would use the department
-    result = propane_department.run({
-        "customer_ids": ["CUST001", "CUST002"],
-        "date_range": {
-            "start": "2024-03-20",
-            "end": "2024-03-27"
-        }
-    })
-    print(f"Workflow result: {result}") 

memra-workflows/text_to_sql/complete_invoice_workflow_with_queries.py

@@ -1,208 +0,0 @@
-#!/usr/bin/env python3
-"""
-Complete Invoice Processing Workflow with Text-to-SQL Integration
-Demonstrates: PDF → Processing → Database → Natural Language Queries
-"""
-
-import os
-import sys
-import json
-from pathlib import Path
-
-# Add the parent directory to the path so we can import memra
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from memra.tool_registry import ToolRegistry
-
-def discover_invoice_files():
-    """Discover PDF files in the invoices directory"""
-    invoices_dir = Path("invoices")
-    if not invoices_dir.exists():
-        invoices_dir.mkdir()
-        return []
-    
-    pdf_files = list(invoices_dir.glob("*.pdf")) + list(invoices_dir.glob("*.PDF"))
-    return [{"filename": f.name, "path": str(f), "size": f"{f.stat().st_size // 1024}KB"} for f in pdf_files]
-
-def get_file_to_process():
-    """Smart file discovery and selection"""
-    files = discover_invoice_files()
-    
-    if len(files) == 0:
-        print("📁 No PDF files found in invoices/ directory")
-        return None
-    
-    elif len(files) == 1:
-        file_info = files[0]
-        print(f"📄 Found 1 file: {file_info['filename']} ({file_info['size']})")
-        print(f"🔄 Auto-processing: {file_info['filename']}")
-        return file_info['path']
-    
-    else:
-        print(f"📁 Found {len(files)} PDF files:")
-        for i, file_info in enumerate(files, 1):
-            print(f"  {i}. {file_info['filename']} ({file_info['size']})")
-        
-        print(f"\n🤔 Multiple files found. What would you like to do?")
-        print(f"   Enter 1-{len(files)} to process a specific file")
-        
-        choice = input("\n📎 Your choice: ").strip().lower()
-        
-        if choice.isdigit():
-            file_num = int(choice)
-            if 1 <= file_num <= len(files):
-                selected_file = files[file_num - 1]
-                print(f"🔄 Processing: {selected_file['filename']}")
-                return selected_file['path']
-        
-        print("❌ Invalid choice")
-        return None
-
-def process_invoice_via_api(file_path):
-    """Process invoice using the Memra API (simulated for demo)"""
-    print(f"\n🔄 Step 1: Processing PDF via Memra API...")
-    print(f"📄 File: {Path(file_path).name}")
-    
-    # In a real implementation, this would call the actual Memra API
-    # For demo purposes, we'll simulate the processing
-    print("⚡ Extracting invoice data...")
-    print("✅ Invoice data extracted successfully")
-    print("⚡ Validating data...")
-    print("✅ Data validation passed")
-    print("⚡ Inserting into database...")
-    print("✅ Database insertion completed")
-    
-    # Return mock record ID
-    return 23
-
-def run_text_to_sql_queries(registry, record_id=None):
-    """Run interactive text-to-SQL queries after invoice processing"""
-    print(f"\n{'='*60}")
-    print("🧠 Business Intelligence Mode")
-    print("Now you can ask questions about your invoice data!")
-    print(f"{'='*60}")
-    
-    # MCP bridge configuration
-    mcp_config = {
-        "bridge_url": "http://localhost:8081",
-        "bridge_secret": "test-secret-for-development"
-    }
-    
-    # Suggested queries
-    suggested_queries = [
-        "How many invoices do we have in the database?",
-        "What is the total amount of all invoices?",
-        "Show me all invoices from Air Liquide",
-        "Show me the most recent 5 invoices"
-    ]
-    
-    if record_id:
-        suggested_queries.insert(0, f"Show me the invoice that was just processed (ID {record_id})")
-    
-    print("💡 Suggested questions:")
-    for i, query in enumerate(suggested_queries, 1):
-        print(f"  {i}. {query}")
-    
-    while True:
-        print(f"\n🤔 What would you like to know about the invoices?")
-        print("   (Enter a question, number for suggestions, or 'done' to finish)")
-        
-        user_input = input("\n❓ Your question: ").strip()
-        
-        if user_input.lower() in ['done', 'exit', 'quit', 'finish']:
-            print("👋 Exiting Business Intelligence mode")
-            break
-        
-        # Handle numbered suggestions
-        if user_input.isdigit():
-            question_num = int(user_input)
-            if 1 <= question_num <= len(suggested_queries):
-                question = suggested_queries[question_num - 1]
-            else:
-                print(f"❌ Please enter a number between 1 and {len(suggested_queries)}")
-                continue
-        else:
-            question = user_input
-        
-        if not question:
-            print("❌ Please enter a question")
-            continue
-        
-        try:
-            print(f"\n🔍 Processing: '{question}'")
-            
-            # Step 1: Generate SQL
-            sql_result = registry.execute_tool(
-                tool_name="TextToSQLGenerator",
-                hosted_by="mcp",
-                input_data={
-                    "question": question,
-                    "schema_info": {"tables": ["invoices"]}
-                },
-                config=mcp_config
-            )
-            
-            if not sql_result.get("success"):
-                print(f"❌ SQL generation failed: {sql_result.get('error')}")
-                continue
-            
-            sql_data = sql_result.get("data", {})
-            generated_sql = sql_data.get("generated_sql", "")
-            print(f"📝 Generated SQL: {generated_sql}")
-            
-            # Step 2: Execute SQL
-            execution_result = registry.execute_tool(
-                tool_name="SQLExecutor",
-                hosted_by="mcp",
-                input_data={"sql_query": generated_sql},
-                config=mcp_config
-            )
-            
-            if execution_result.get("success"):
-                query_results = execution_result.get("data", {})
-                results = query_results.get("results", [])
-                row_count = query_results.get("row_count", 0)
-                
-                print(f"\n📊 Results ({row_count} rows):")
-                if results:
-                    for i, row in enumerate(results[:3]):
-                        print(f"  {i+1}. {row}")
-                    if len(results) > 3:
-                        print(f"  ... and {len(results) - 3} more rows")
-                else:
-                    print("  No results found")
-                
-                if not query_results.get("_mock"):
-                    print("✅ Real database results!")
-            else:
-                print(f"❌ Query execution failed: {execution_result.get('error')}")
-                
-        except Exception as e:
-            print(f"❌ Error: {str(e)}")
-
-def main():
-    """Main workflow: PDF processing + Text-to-SQL queries"""
-    print("🚀 Complete Invoice Processing & Analytics Workflow")
-    print("=" * 60)
-    
-    # Step 1: Discover and select files
-    file_to_process = get_file_to_process()
-    if not file_to_process:
-        print("❌ No file selected. Exiting.")
-        return
-    
-    # Step 2: Process the invoice
-    record_id = process_invoice_via_api(file_to_process)
-    
-    if record_id:
-        print(f"\n✅ Invoice processing completed!")
-        print(f"📊 Database Record ID: {record_id}")
-        
-        # Step 3: Offer text-to-SQL queries
-        registry = ToolRegistry()
-        run_text_to_sql_queries(registry, record_id)
-    else:
-        print("❌ Invoice processing failed")
-
-if __name__ == "__main__":
-    main()