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

memra/demos/etl_invoice_processing/test_upload_server.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+Local Test Server for File Upload Functionality
+This simulates the remote API upload endpoint for testing
+"""
+
+import base64
+import os
+import uuid
+import asyncio
+from datetime import datetime, timedelta
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+import uvicorn
+
+# Models
+class FileUploadRequest(BaseModel):
+    filename: str
+    content: str  # base64 encoded
+    content_type: str
+
+class FileUploadResponse(BaseModel):
+    success: bool
+    data: Optional[dict] = None
+    error: Optional[str] = None
+
+class ToolExecuteRequest(BaseModel):
+    tool_name: str
+    hosted_by: str
+    input_data: dict
+
+class ToolExecuteResponse(BaseModel):
+    success: bool
+    data: Optional[dict] = None
+    error: Optional[str] = None
+
+# File storage configuration
+UPLOAD_DIR = "/tmp/test_uploads"
+FILE_EXPIRY_HOURS = 24
+
+# Ensure upload directory exists
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+app = FastAPI(title="Test Upload Server", version="1.0.0")
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "timestamp": datetime.utcnow().isoformat()}
+
+@app.post("/upload", response_model=FileUploadResponse)
+async def upload_file(request: FileUploadRequest):
+    """Upload a file to the server for processing"""
+    try:
+        # Validate file type
+        if not request.content_type.startswith("application/pdf"):
+            raise HTTPException(status_code=400, detail="Only PDF files are supported")
+        
+        # Validate file size (50MB limit)
+        try:
+            file_content = base64.b64decode(request.content)
+            if len(file_content) > 50 * 1024 * 1024:  # 50MB
+                raise HTTPException(status_code=400, detail="File too large (max 50MB)")
+        except Exception as e:
+            raise HTTPException(status_code=400, detail="Invalid base64 content")
+        
+        # Generate unique filename
+        file_id = str(uuid.uuid4())
+        file_extension = os.path.splitext(request.filename)[1]
+        remote_filename = f"{file_id}{file_extension}"
+        remote_path = os.path.join(UPLOAD_DIR, remote_filename)
+        
+        # Save file
+        with open(remote_path, 'wb') as f:
+            f.write(file_content)
+        
+        # Calculate expiry time
+        expires_at = datetime.utcnow() + timedelta(hours=FILE_EXPIRY_HOURS)
+        
+        print(f"📤 Uploaded file: {request.filename} -> {remote_filename}")
+        
+        return FileUploadResponse(
+            success=True,
+            data={
+                "remote_path": f"/uploads/{remote_filename}",
+                "file_id": file_id,
+                "expires_at": expires_at.isoformat(),
+                "original_filename": request.filename
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        return FileUploadResponse(
+            success=False,
+            error=f"Upload failed: {str(e)}"
+        )
+
+@app.post("/tools/execute", response_model=ToolExecuteResponse)
+async def execute_tool(request: ToolExecuteRequest):
+    """Execute a tool (simulated PDFProcessor)"""
+    try:
+        if request.tool_name == "PDFProcessor":
+            return await simulate_pdf_processor(request.input_data)
+        else:
+            return ToolExecuteResponse(
+                success=False,
+                error=f"Unknown tool: {request.tool_name}"
+            )
+    except Exception as e:
+        return ToolExecuteResponse(
+            success=False,
+            error=str(e)
+        )
+
+async def simulate_pdf_processor(input_data: dict) -> ToolExecuteResponse:
+    """Simulate PDF processing"""
+    try:
+        file_path = input_data.get('file', '')
+        
+        if not file_path:
+            return ToolExecuteResponse(
+                success=False,
+                error="No file path provided"
+            )
+        
+        # Handle uploaded files
+        if file_path.startswith('/uploads/'):
+            full_path = os.path.join(UPLOAD_DIR, os.path.basename(file_path))
+        else:
+            full_path = file_path
+        
+        if not os.path.exists(full_path):
+            return ToolExecuteResponse(
+                success=False,
+                error=f"PDF file not found: {file_path}"
+            )
+        
+        # Simulate processing (in real implementation, this would use vision model)
+        print(f"🔍 Processing PDF: {file_path}")
+        
+        # Mock extracted data
+        invoice_data = {
+            "headerSection": {
+                "vendorName": "Test Vendor Corp",
+                "subtotal": 1234.56
+            },
+            "billingDetails": {
+                "invoiceNumber": "INV-001",
+                "invoiceDate": "2024-01-15"
+            },
+            "chargesSummary": {
+                "document_total": 1395.05,
+                "secondary_tax": 160.49,
+                "lineItemsBreakdown": [
+                    {
+                        "description": "Test Product",
+                        "quantity": 1,
+                        "unit_price": 1234.56,
+                        "amount": 1234.56,
+                        "main_product": True
+                    }
+                ]
+            }
+        }
+        
+        return ToolExecuteResponse(
+            success=True,
+            data={
+                "file_path": file_path,
+                "extracted_data": invoice_data
+            }
+        )
+        
+    except Exception as e:
+        return ToolExecuteResponse(
+            success=False,
+            error=str(e)
+        )
+
+@app.get("/tools/discover")
+async def discover_tools():
+    """Discover available tools"""
+    return {
+        "tools": [
+            {
+                "name": "PDFProcessor",
+                "hosted_by": "memra",
+                "description": "Process PDF files and extract content"
+            },
+            {
+                "name": "InvoiceExtractionWorkflow",
+                "hosted_by": "memra", 
+                "description": "Extract structured data from invoices"
+            }
+        ]
+    }
+
+async def cleanup_expired_files():
+    """Remove files older than FILE_EXPIRY_HOURS"""
+    while True:
+        try:
+            current_time = datetime.utcnow()
+            for filename in os.listdir(UPLOAD_DIR):
+                file_path = os.path.join(UPLOAD_DIR, filename)
+                file_time = datetime.fromtimestamp(os.path.getctime(file_path))
+                
+                if current_time - file_time > timedelta(hours=FILE_EXPIRY_HOURS):
+                    try:
+                        os.remove(file_path)
+                        print(f"🧹 Cleaned up expired file: {filename}")
+                    except Exception as e:
+                        print(f"Failed to clean up {filename}: {e}")
+                        
+        except Exception as e:
+            print(f"File cleanup error: {e}")
+            
+        await asyncio.sleep(3600)  # Run every hour
+
+@app.on_event("startup")
+async def start_cleanup():
+    asyncio.create_task(cleanup_expired_files())
+
+if __name__ == "__main__":
+    print("🚀 Starting Test Upload Server...")
+    print(f"📁 Upload directory: {UPLOAD_DIR}")
+    print("🌐 Server will be available at: http://localhost:8000")
+    print("📚 API docs available at: http://localhost:8000/docs")
+    
+    uvicorn.run(app, host="0.0.0.0", port=8000) 

memra/demos/etl_invoice_processing/test_vision_output.py

@@ -0,0 +1,75 @@
+import os
+import requests
+import json
+
+api_url = "https://api.memra.co"
+api_key = os.getenv("MEMRA_API_KEY", "test-secret-for-development")
+
+# Test with a comprehensive schema that includes all fields
+schema = [
+    {"column_name": "vendor_name", "data_type": "character varying"},
+    {"column_name": "invoice_number", "data_type": "character varying"},
+    {"column_name": "invoice_date", "data_type": "date"},
+    {"column_name": "due_date", "data_type": "date"},
+    {"column_name": "total_amount", "data_type": "numeric"},
+    {"column_name": "tax_amount", "data_type": "numeric"},
+    {"column_name": "line_items", "data_type": "jsonb"}
+]
+
+resp = requests.post(
+    f"{api_url}/tools/execute",
+    json={
+        "tool_name": "PDFProcessor",
+        "hosted_by": "memra",
+        "input_data": {
+            "file": "/uploads/6f4538c0-8fce-4488-be49-1a78afc58a4a.pdf",
+            "schema": schema
+        }
+    },
+    headers={"X-API-Key": api_key}
+)
+
+print(f"Status: {resp.status_code}")
+if resp.status_code == 200:
+    result = resp.json()
+    print(f"\nSuccess: {result.get('success')}")
+    
+    if 'data' in result and 'data' in result['data']:
+        inner_data = result['data']['data']
+        
+        # Print the vision response
+        if 'vision_response' in inner_data:
+            print("\n=== VISION MODEL RAW RESPONSE ===")
+            vision_resp = inner_data['vision_response']
+            try:
+                # Try to parse and pretty print if it's JSON
+                parsed = json.loads(vision_resp)
+                print(json.dumps(parsed, indent=2))
+            except:
+                print(vision_resp)
+            print("=" * 40)
+        
+        # Print the extracted data after transformation
+        if 'extracted_data' in inner_data:
+            print("\n=== TRANSFORMED DATA (MCP Format) ===")
+            extracted = inner_data['extracted_data']
+            print(json.dumps(extracted, indent=2))
+            
+            # Check specific fields
+            print("\n=== FIELD ANALYSIS ===")
+            billing = extracted.get('billingDetails', {})
+            charges = extracted.get('chargesSummary', {})
+            
+            print(f"due_date: '{billing.get('dueDate', 'MISSING')}'")
+            print(f"total_amount: {charges.get('document_total', 'MISSING')}")
+            print(f"tax_amount: {charges.get('secondary_tax', 'MISSING')}")
+            print("=" * 40)
+            
+            # Save to file for easier viewing
+            with open("vision_output.json", "w") as f:
+                json.dump({
+                    "vision_response": inner_data.get('vision_response', ''),
+                    "extracted_data": extracted
+                }, f, indent=2)
+else:
+    print(f"Error: {resp.text}")

memra/demos/etl_invoice_processing/test_vision_prompt.py

@@ -0,0 +1,43 @@
+# Test what happens when we pass schema to PDFProcessor
+import os
+import requests
+import json
+
+api_url = "https://api.memra.co"
+api_key = os.getenv("MEMRA_API_KEY", "test-secret-for-development")
+
+# Schema that matches database fields
+schema = [
+    {"column_name": "invoice_number", "data_type": "character varying", "is_nullable": "NO"},
+    {"column_name": "vendor_name", "data_type": "character varying", "is_nullable": "NO"},
+    {"column_name": "invoice_date", "data_type": "date", "is_nullable": "NO"},
+    {"column_name": "total_amount", "data_type": "numeric", "is_nullable": "NO"}
+]
+
+print("Testing with database schema format:")
+resp = requests.post(
+    f"{api_url}/tools/execute",
+    json={
+        "tool_name": "PDFProcessor",
+        "hosted_by": "memra",
+        "input_data": {
+            "file": "/uploads/6f4538c0-8fce-4488-be49-1a78afc58a4a.pdf",
+            "schema": schema
+        }
+    },
+    headers={"X-API-Key": api_key}
+)
+
+if resp.status_code == 200:
+    result = resp.json()
+    if result.get('success') and 'data' in result and 'data' in result['data']:
+        vision_prompt = result['data']['data'].get('vision_prompt', '')
+        print("\nVision prompt with schema:")
+        print(vision_prompt)
+        
+        # Check if vendor was extracted
+        vision_resp = result['data']['data'].get('vision_response', '')
+        if 'vendor' in vision_resp.lower():
+            print("\n✅ Vision model extracted vendor info\!")
+        else:
+            print("\n❌ Vision model did not extract vendor info")

memra/demos/etl_invoice_processing/test_vision_simple.py

@@ -0,0 +1,60 @@
+import os
+import requests
+import json
+
+api_url = "https://api.memra.co"
+api_key = os.getenv("MEMRA_API_KEY", "test-secret-for-development")
+
+# Test with a comprehensive schema that includes all fields
+schema = [
+    {"column_name": "vendor_name", "data_type": "character varying"},
+    {"column_name": "invoice_number", "data_type": "character varying"},
+    {"column_name": "invoice_date", "data_type": "date"},
+    {"column_name": "due_date", "data_type": "date"},
+    {"column_name": "total_amount", "data_type": "numeric"},
+    {"column_name": "tax_amount", "data_type": "numeric"},
+    {"column_name": "line_items", "data_type": "jsonb"}
+]
+
+resp = requests.post(
+    f"{api_url}/tools/execute",
+    json={
+        "tool_name": "PDFProcessor",
+        "hosted_by": "memra",
+        "input_data": {
+            "file": "/uploads/6f4538c0-8fce-4488-be49-1a78afc58a4a.pdf",
+            "schema": schema
+        }
+    },
+    headers={"X-API-Key": api_key}
+)
+
+print(f"Status: {resp.status_code}")
+if resp.status_code == 200:
+    result = resp.json()
+    
+    if 'data' in result and 'data' in result['data']:
+        inner_data = result['data']['data']
+        
+        # Get the vision response
+        if 'vision_response' in inner_data:
+            try:
+                vision_parsed = json.loads(inner_data['vision_response'])
+                print("\nVision Model Response Fields:")
+                for key, value in vision_parsed.items():
+                    print(f"  {key}: {value}")
+            except:
+                print("Could not parse vision response as JSON")
+        
+        # Get the extracted data
+        if 'extracted_data' in inner_data:
+            extracted = inner_data['extracted_data']
+            billing = extracted.get('billingDetails', {})
+            charges = extracted.get('chargesSummary', {})
+            
+            print("\nExtracted Fields:")
+            print(f"  due_date: '{billing.get('dueDate', 'MISSING')}'")
+            print(f"  total_amount: {charges.get('document_total', 'MISSING')}")
+            print(f"  tax_amount: {charges.get('secondary_tax', 'MISSING')}")
+else:
+    print(f"Error: {resp.text}")

{memra-0.2.12.dist-info → memra-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: memra
-Version: 0.2.12
+Version: 0.2.13
 Summary: Declarative framework for enterprise workflows with MCP integration - Client SDK
 Home-page: https://github.com/memra/memra-sdk
 Author: Memra
@@ -20,22 +20,18 @@ 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
+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"
+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: license-file
-Dynamic: requires-python
+Requires-Dist: psycopg2-binary >=2.9.0 ; extra == 'mcp'
 
 # Memra SDK
 
@@ -56,24 +52,26 @@ Building AI-powered business workflows is hard. You need to:
 
 **Memra solves these challenges** by providing a declarative framework that lets you focus on *what* you want to accomplish, not *how* to wire everything together.
 
-## 🚀 Quick Start (5 minutes!)
+## 🚀 Quick Start (2 minutes!)
 
-**Want to see Memra in action immediately?** Check out our [Quick Start Guide](QUICK_START.md) to run the ETL demo in minutes!
-
-### Installation
+**Want to see Memra in action immediately?**
 
 ```bash
+# Install Memra
 pip install memra
-```
 
-**📖 New to Memra?** For a complete beginner-friendly setup with step-by-step instructions, see our [Detailed Installation Guide](INSTALLATION_GUIDE.md) or run our automated setup script:
-
-```bash
-# Automated setup for new users
-bash scripts/setup_newbie.sh
+# Run the ETL demo
+memra demo
 ```
 
-**🔧 Repository Structure:** This repo uses git submodules with sparse checkout to provide minimal access to infrastructure and workflow templates while keeping private content secure.
+**That's it!** The demo will automatically:
+- ✅ Set up PostgreSQL database
+- ✅ Start MCP bridge server
+- ✅ Process PDF invoices with AI vision
+- ✅ Store data in the database
+- ✅ Show you the results
+
+**📖 Need more details?** Check out our [Quick Start Guide](QUICK_START.md) for step-by-step instructions.
 
 ### Basic Example
 
@@ -139,7 +137,7 @@ Configuration for language models used by agents, supporting:
 
 ```bash
 # Run the ETL demo
-python demos/etl_invoice_processing/etl_invoice_demo.py
+memra demo
 ```
 
 This demo showcases:
@@ -241,43 +239,19 @@ Scale from prototype to production:
 ## 📚 Documentation
 
 - **[Quick Start Guide](QUICK_START.md)** - Get up and running in 5 minutes
-- **[Detailed Installation Guide](INSTALLATION_GUIDE.md)** - Complete beginner-friendly setup instructions
+- **[Installation Guide](INSTALLATION_GUIDE.md)** - Detailed setup instructions
+- **[Text-to-SQL Guide](TEXT_TO_SQL_USAGE_GUIDE.md)** - Build SQL queries with natural language
+- **[Contributing](CONTRIBUTING.md)** - How to contribute to Memra
 - **[System Architecture](memra_system_architecture.md)** - Deep dive into Memra's design
-- **[Text-to-SQL Guide](TEXT_TO_SQL_USAGE_GUIDE.md)** - Building database query workflows
-- **[Examples Directory](examples/)** - Complete working examples
-- **[Demos Directory](demos/)** - Advanced workflow demonstrations
-
-## 🏢 Use Cases
-
-### Financial Services
-- **Invoice processing** and accounts payable automation
-- **Document classification** and routing
-- **Compliance monitoring** and reporting
-- **Risk assessment** and fraud detection
-
-### Healthcare
-- **Medical record processing** and data extraction
-- **Claims processing** and validation
-- **Patient data analysis** and insights
-- **Regulatory compliance** workflows
-
-### Manufacturing
-- **Quality control** and inspection workflows
-- **Supply chain** optimization and monitoring
-- **Equipment maintenance** scheduling
-- **Production planning** and optimization
-
-### Retail & E-commerce
-- **Order processing** and fulfillment
-- **Customer service** automation
-- **Inventory management** and forecasting
-- **Market analysis** and trend detection
 
-## 🤝 Contributing
+## 🔧 Development
 
-We welcome contributions! Please see our [contributing guide](CONTRIBUTING.md) for details.
+### Prerequisites
+- Python 3.8+
+- Docker (for database and services)
+- Git
 
-### Development Setup
+### Local Development Setup
 
 ```bash
 # Clone the repository
@@ -287,33 +261,34 @@ cd memra-sdk
 # Install in development mode
 pip install -e .
 
-# Run tests
-pytest tests/
+# Run the demo
+memra demo
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+python -m pytest tests/
+
+# Run specific test file
+python -m pytest tests/test_execution.py
 ```
 
 ## 📄 License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-### MIT License Summary
-- ✅ **Commercial use** - Use in proprietary software
-- ✅ **Modification** - Modify and distribute
-- ✅ **Distribution** - Distribute copies
-- ✅ **Private use** - Use privately
-- ❌ **Liability** - No warranty provided
-- ❌ **Warranty** - No warranty provided
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details on how to submit pull requests, report issues, and contribute to the project.
 
-## 🆘 Support
+## 📞 Support
 
+- **Documentation**: Check our guides above
 - **Issues**: [GitHub Issues](https://github.com/memra-platform/memra-sdk/issues)
 - **Discussions**: [GitHub Discussions](https://github.com/memra-platform/memra-sdk/discussions)
-- **Email**: hello@memra.com
-
-## 🔗 Related Projects
-
-- **[memra-workflows](https://github.com/memra-platform/memra-workflows)** - Production workflow templates
-- **[memra-ops](https://github.com/memra-platform/memra-ops)** - Operations and deployment tools
 
 ---
 
-**Built with ❤️ by the memra team** 
+**Ready to build AI workflows that scale?** Start with `pip install memra` and `memra demo`! 🚀