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

memra/__init__.py

@@ -6,7 +6,7 @@ Think of it as "Kubernetes for business logic" where agents are the pods and
 departments are the deployments.
 """
 
-__version__ = "0.2.12"
+__version__ = "0.2.15"
 
 # Core imports
 from .models import Agent, Department, Tool, LLM

memra/cli.py

@@ -24,9 +24,6 @@ def run_demo():
     print("🔧 Configuring environment...")
     setup_environment()
     
-    # Step 2.5: Install dependencies
-    install_dependencies()
-    
     # Step 3: Start Docker containers
     print("🐳 Starting Docker services...")
     if not start_docker_services(demo_dir):
@@ -37,18 +34,11 @@ def run_demo():
     print("⏳ Waiting for services to be ready...")
     wait_for_services()
     
-    # Step 5: Start MCP bridge server
-    print("🔌 Starting MCP bridge server...")
-    if not start_mcp_bridge_server(demo_dir):
-        print("❌ Failed to start MCP bridge server.")
-        print("   You can start it manually: cd memra-ops && python mcp_bridge_server.py")
-        return False
-    
-    # Step 6: Run the demo
+    # Step 5: Run the demo
     print("🎯 Running ETL workflow...")
     success = run_etl_workflow(demo_dir)
     
-    # Step 7: Show results
+    # Step 6: Show results
     if success:
         print("=" * 50)
         print("🎉 Demo completed successfully!")
@@ -60,7 +50,6 @@ def run_demo():
         print("  • Check database: docker exec -it memra_postgres psql -U postgres -d local_workflow")
         print("  • View data: SELECT * FROM invoices ORDER BY created_at DESC;")
         print("  • Stop services: cd memra-ops && docker compose down")
-        print("  • Stop MCP server: pkill -f mcp_bridge_server.py")
         print("  • Explore code: Check the extracted files in the demo directory")
     else:
         print("❌ Demo failed. Check the logs above for details.")
@@ -87,217 +76,15 @@ def setup_demo_environment():
 def extract_bundled_files(demo_dir):
     """Extract files bundled with the PyPI package"""
     try:
-        import pkg_resources
-        import shutil
-        from pathlib import Path
-        
-        # Extract demo files from package data
-        demo_dir.mkdir(exist_ok=True)
-        
-        # Copy the main ETL demo script
-        try:
-            demo_script = pkg_resources.resource_filename('memra', 'demos/etl_invoice_processing/etl_invoice_demo.py')
-            if Path(demo_script).exists():
-                shutil.copy2(demo_script, demo_dir / "etl_invoice_demo.py")
-                print("✅ Copied ETL demo script")
-            else:
-                print("⚠️  ETL demo script not found in package")
-        except Exception as e:
-            print(f"⚠️  Could not copy ETL demo script: {e}")
-        
-        # Copy supporting Python files
-        demo_files = [
-            "database_monitor_agent.py",
-            "simple_pdf_processor.py", 
-            "setup_demo_data.py"
-        ]
-        
-        for file_name in demo_files:
-            try:
-                file_path = pkg_resources.resource_filename('memra', f'demos/etl_invoice_processing/{file_name}')
-                if Path(file_path).exists():
-                    shutil.copy2(file_path, demo_dir / file_name)
-                    print(f"✅ Copied {file_name}")
-                else:
-                    print(f"⚠️  {file_name} not found in package")
-            except Exception as e:
-                print(f"⚠️  Could not copy {file_name}: {e}")
-        
-        # Copy sample data directory
-        try:
-            data_source = pkg_resources.resource_filename('memra', 'demos/etl_invoice_processing/data')
-            if Path(data_source).exists():
-                data_dir = demo_dir / "data"
-                shutil.copytree(data_source, data_dir, dirs_exist_ok=True)
-                print("✅ Copied sample invoice data")
+        # Extract from package data
+        with pkg_resources.path('memra', 'demo_files') as demo_files_path:
+            if demo_files_path.exists():
+                # Copy all files from the bundled demo_files directory
+                shutil.copytree(demo_files_path, demo_dir, dirs_exist_ok=True)
             else:
-                print("⚠️  Sample data not found in package")
-        except Exception as e:
-            print(f"⚠️  Could not copy sample data: {e}")
-        
-        # Create memra-ops directory with docker-compose
-        ops_dir = demo_dir / "memra-ops"
-        ops_dir.mkdir(exist_ok=True)
-        
-        # Create basic docker-compose.yml
-        compose_content = """version: '3.8'
-services:
-  postgres:
-    image: postgres:15
-    environment:
-      POSTGRES_DB: local_workflow
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-    ports:
-      - "5432:5432"
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-
-volumes:
-  postgres_data:
-"""
-        
-        with open(ops_dir / "docker-compose.yml", "w") as f:
-            f.write(compose_content)
-        
-        # Create basic MCP bridge server
-        mcp_content = """#!/usr/bin/env python3
-import asyncio
-import aiohttp
-from aiohttp import web
-import json
-import psycopg2
-import os
-
-class MCPBridgeServer:
-    def __init__(self):
-        self.db_url = os.getenv('DATABASE_URL', 'postgresql://postgres:postgres@localhost:5432/local_workflow')
-    
-    async def health_handler(self, request):
-        return web.json_response({"status": "healthy", "server": "MCP Bridge"})
-    
-    async def execute_tool_handler(self, request):
-        try:
-            data = await request.json()
-            tool_name = data.get('tool_name', 'unknown')
-            tool_params = data.get('parameters', {})
-            
-            if tool_name == 'SQLExecutor':
-                return await self.execute_sql(tool_params)
-            elif tool_name == 'PostgresInsert':
-                return await self.insert_data(tool_params)
-            elif tool_name == 'DataValidator':
-                return await self.validate_data(tool_params)
-            else:
-                return web.json_response({
-                    "success": True,
-                    "message": f"Demo {tool_name} executed",
-                    "data": {"demo": True}
-                })
-        except Exception as e:
-            return web.json_response({
-                "success": False,
-                "error": str(e)
-            }, status=500)
-    
-    async def execute_sql(self, params):
-        try:
-            query = params.get('query', 'SELECT 1')
-            conn = psycopg2.connect(self.db_url)
-            cursor = conn.cursor()
-            cursor.execute(query)
-            results = cursor.fetchall()
-            cursor.close()
-            conn.close()
-            
-            return web.json_response({
-                "success": True,
-                "results": results,
-                "query": query
-            })
-        except Exception as e:
-            return web.json_response({
-                "success": False,
-                "error": f"SQL execution failed: {str(e)}"
-            }, status=500)
-    
-    async def insert_data(self, params):
-        try:
-            table_name = params.get('table_name', 'invoices')
-            data = params.get('data', {})
-            
-            conn = psycopg2.connect(self.db_url)
-            cursor = conn.cursor()
-            
-            # Simple insert logic
-            columns = list(data.keys())
-            values = list(data.values())
-            placeholders = ', '.join(['%s'] * len(values))
-            column_list = ', '.join(columns)
-            
-            query = f"INSERT INTO {table_name} ({column_list}) VALUES ({placeholders}) RETURNING id"
-            cursor.execute(query, values)
-            record_id = cursor.fetchone()[0]
-            
-            conn.commit()
-            cursor.close()
-            conn.close()
-            
-            return web.json_response({
-                "success": True,
-                "record_id": record_id,
-                "message": f"Inserted into {table_name}"
-            })
-        except Exception as e:
-            return web.json_response({
-                "success": False,
-                "error": f"Insert failed: {str(e)}"
-            }, status=500)
-    
-    async def validate_data(self, params):
-        try:
-            data = params.get('data', {})
-            
-            # Simple validation
-            is_valid = True
-            errors = []
-            
-            if not data.get('vendor_name'):
-                is_valid = False
-                errors.append("Missing vendor name")
-            
-            if not data.get('amount') or float(data.get('amount', 0)) <= 0:
-                is_valid = False
-                errors.append("Invalid amount")
-            
-            return web.json_response({
-                "success": True,
-                "is_valid": is_valid,
-                "errors": errors,
-                "validated_data": data
-            })
-        except Exception as e:
-            return web.json_response({
-                "success": False,
-                "error": f"Validation failed: {str(e)}"
-            }, status=500)
-
-# Create server instance
-server = MCPBridgeServer()
-
-# Create web application
-app = web.Application()
-app.router.add_get('/health', server.health_handler)
-app.router.add_post('/execute_tool', server.execute_tool_handler)
-
-if __name__ == '__main__':
-    print("🚀 Starting MCP Bridge Server on port 8081...")
-    web.run_app(app, host='0.0.0.0', port=8081)
-"""
-        
-        with open(ops_dir / "mcp_bridge_server.py", "w") as f:
-            f.write(mcp_content)
-            
+                # Fallback: create minimal demo structure
+                create_minimal_demo(demo_dir)
+                
     except Exception as e:
         print(f"⚠️  Could not extract bundled files: {e}")
         print("Creating minimal demo structure...")
@@ -336,173 +123,45 @@ import asyncio
 import aiohttp
 from aiohttp import web
 import json
-import psycopg2
-import os
 
-class MCPBridgeServer:
-    def __init__(self):
-        self.db_url = os.getenv('DATABASE_URL', 'postgresql://postgres:postgres@localhost:5432/local_workflow')
-    
-    async def health_handler(self, request):
-        return web.json_response({"status": "healthy", "server": "MCP Bridge"})
-    
-    async def execute_tool_handler(self, request):
-        try:
-            data = await request.json()
-            tool_name = data.get('tool_name', 'unknown')
-            tool_params = data.get('parameters', {})
-            
-            if tool_name == 'SQLExecutor':
-                return await self.execute_sql(tool_params)
-            elif tool_name == 'PostgresInsert':
-                return await self.insert_data(tool_params)
-            elif tool_name == 'DataValidator':
-                return await self.validate_data(tool_params)
-            else:
-                return web.json_response({
-                    "success": True,
-                    "message": f"Demo {tool_name} executed",
-                    "data": {"demo": True}
-                })
-        except Exception as e:
-            return web.json_response({
-                "success": False,
-                "error": str(e)
-            }, status=500)
-    
-    async def execute_sql(self, params):
-        try:
-            query = params.get('query', 'SELECT 1')
-            conn = psycopg2.connect(self.db_url)
-            cursor = conn.cursor()
-            cursor.execute(query)
-            results = cursor.fetchall()
-            cursor.close()
-            conn.close()
-            
-            return web.json_response({
-                "success": True,
-                "results": results,
-                "query": query
-            })
-        except Exception as e:
-            return web.json_response({
-                "success": False,
-                "error": f"SQL execution failed: {str(e)}"
-            }, status=500)
-    
-    async def insert_data(self, params):
-        try:
-            table_name = params.get('table_name', 'invoices')
-            data = params.get('data', {})
-            
-            conn = psycopg2.connect(self.db_url)
-            cursor = conn.cursor()
-            
-            # Simple insert logic
-            columns = list(data.keys())
-            values = list(data.values())
-            placeholders = ', '.join(['%s'] * len(values))
-            column_list = ', '.join(columns)
-            
-            query = f"INSERT INTO {table_name} ({column_list}) VALUES ({placeholders}) RETURNING id"
-            cursor.execute(query, values)
-            record_id = cursor.fetchone()[0]
-            
-            conn.commit()
-            cursor.close()
-            conn.close()
-            
-            return web.json_response({
-                "success": True,
-                "record_id": record_id,
-                "message": f"Inserted into {table_name}"
-            })
-        except Exception as e:
-            return web.json_response({
-                "success": False,
-                "error": f"Insert failed: {str(e)}"
-            }, status=500)
-    
-    async def validate_data(self, params):
-        try:
-            data = params.get('data', {})
-            
-            # Simple validation
-            is_valid = True
-            errors = []
-            
-            if not data.get('vendor_name'):
-                is_valid = False
-                errors.append("Missing vendor name")
-            
-            if not data.get('amount') or float(data.get('amount', 0)) <= 0:
-                is_valid = False
-                errors.append("Invalid amount")
-            
-            return web.json_response({
-                "success": True,
-                "is_valid": is_valid,
-                "errors": errors,
-                "validated_data": data
-            })
-        except Exception as e:
-            return web.json_response({
-                "success": False,
-                "error": f"Validation failed: {str(e)}"
-            }, status=500)
+async def health_handler(request):
+    return web.json_response({"status": "healthy"})
 
-# Create server instance
-server = MCPBridgeServer()
+async def execute_tool_handler(request):
+    data = await request.json()
+    tool_name = data.get('tool_name', 'unknown')
+    
+    # Mock responses for demo
+    if tool_name == 'SQLExecutor':
+        return web.json_response({
+            "success": True,
+            "results": [{"message": "Demo SQL executed"}]
+        })
+    elif tool_name == 'PostgresInsert':
+        return web.json_response({
+            "success": True,
+            "id": 1
+        })
+    else:
+        return web.json_response({
+            "success": True,
+            "message": f"Demo {tool_name} executed"
+        })
 
-# Create web application
 app = web.Application()
-app.router.add_get('/health', server.health_handler)
-app.router.add_post('/execute_tool', server.execute_tool_handler)
+app.router.add_get('/health', health_handler)
+app.router.add_post('/execute_tool', execute_tool_handler)
 
 if __name__ == '__main__':
-    print("🚀 Starting MCP Bridge Server on port 8081...")
     web.run_app(app, host='0.0.0.0', port=8081)
 """
     
     with open(ops_dir / "mcp_bridge_server.py", "w") as f:
         f.write(mcp_content)
     
-    # Copy the real ETL demo if available
+    # Create demo workflow
     demo_dir.mkdir(exist_ok=True)
-    import shutil
-    
-    try:
-        # Try to copy from demos directory
-        source_demo = Path("demos/etl_invoice_processing/etl_invoice_demo.py")
-        if source_demo.exists():
-            # Copy the main demo script
-            shutil.copy2(source_demo, demo_dir / "etl_invoice_demo.py")
-            print("✅ Copied real ETL demo script")
-            
-            # Copy all necessary Python dependencies
-            demo_files = [
-                "database_monitor_agent.py",
-                "simple_pdf_processor.py",
-                "setup_demo_data.py"
-            ]
-            
-            for file_name in demo_files:
-                source_file = Path(f"demos/etl_invoice_processing/{file_name}")
-                if source_file.exists():
-                    shutil.copy2(source_file, demo_dir / file_name)
-                    print(f"✅ Copied {file_name}")
-            
-            # Copy sample data
-            data_dir = demo_dir / "data"
-            data_dir.mkdir(exist_ok=True)
-            source_data = Path("demos/etl_invoice_processing/data")
-            if source_data.exists():
-                shutil.copytree(source_data, data_dir, dirs_exist_ok=True)
-                print("✅ Copied sample invoice data")
-        else:
-            # Create a basic demo if real one not found
-            demo_content = """#!/usr/bin/env python3
+    demo_content = """#!/usr/bin/env python3
 import os
 import sys
 import time
@@ -535,47 +194,9 @@ def main():
 if __name__ == "__main__":
     main()
 """
-            with open(demo_dir / "etl_demo.py", "w") as f:
-                f.write(demo_content)
-            print("⚠️  Using simplified demo (real demo not found)")
-    except Exception as e:
-        print(f"Warning: Could not copy ETL demo: {e}")
-        # Fallback to basic demo
-        demo_content = """#!/usr/bin/env python3
-import os
-import sys
-import time
-
-def main():
-    print("🚀 Starting ETL Invoice Processing Demo...")
-    print("🏢 Starting ETL Invoice Processing Department")
-    print("📋 Mission: Complete end-to-end ETL process with comprehensive monitoring")
-    print("👥 Team: Pre-ETL Database Monitor, Data Engineer, Invoice Parser, Data Entry Specialist, Post-ETL Database Monitor")
-    print("👔 Manager: ETL Process Manager")
     
-    steps = [
-        ("Pre-ETL Database Monitor", "Database state captured: 2 rows"),
-        ("Data Engineer", "Schema extracted successfully"),
-        ("Invoice Parser", "Invoice data extracted: $270.57"),
-        ("Data Entry Specialist", "Record inserted: ID 1"),
-        ("Post-ETL Database Monitor", "Database state captured: 3 rows")
-    ]
-    
-    for i, (step, result) in enumerate(steps, 1):
-        print(f"\\n🔄 Step {i}/5: {step}")
-        time.sleep(1)
-        print(f"✅ {result}")
-    
-    print("\\n🎉 ETL Invoice Processing Department workflow completed!")
-    print("⏱️  Total time: 5.2s")
-    print("\\n📊 Demo completed successfully!")
-    print("This was a simplified demo. For the full experience, check out the complete ETL workflow.")
-
-if __name__ == "__main__":
-    main()
-"""
-        with open(demo_dir / "etl_demo.py", "w") as f:
-            f.write(demo_content)
+    with open(demo_dir / "etl_demo.py", "w") as f:
+        f.write(demo_content)
 
 def setup_environment():
     """Set up environment variables for the demo"""
@@ -588,38 +209,6 @@ def setup_environment():
     os.environ['DATABASE_URL'] = 'postgresql://postgres:postgres@localhost:5432/local_workflow'
     print("✅ Set DATABASE_URL")
 
-def install_dependencies():
-    """Install required dependencies for the demo"""
-    try:
-        print("📦 Installing demo dependencies...")
-        dependencies = [
-            'requests==2.31.0',
-            'fastapi==0.104.1',
-            'uvicorn[standard]==0.24.0',
-            'pydantic==2.5.0',
-            'aiohttp',
-            'psycopg2-binary',
-            'httpx',
-            'huggingface_hub'
-        ]
-        
-        for dep in dependencies:
-            print(f"   Installing {dep}...")
-            result = subprocess.run([
-                sys.executable, '-m', 'pip', 'install', dep
-            ], capture_output=True, text=True)
-            
-            if result.returncode != 0:
-                print(f"⚠️  Warning: Failed to install {dep}: {result.stderr}")
-            else:
-                print(f"   ✅ {dep} installed")
-        
-        print("✅ Dependencies installed")
-        
-    except Exception as e:
-        print(f"⚠️  Warning: Could not install dependencies: {e}")
-        print("   You may need to install them manually: pip install requests fastapi uvicorn pydantic")
-
 def start_docker_services(demo_dir):
     """Start Docker containers using docker-compose"""
     try:
@@ -657,23 +246,9 @@ def wait_for_services():
     """Wait for services to be ready"""
     print("⏳ Waiting for PostgreSQL to be ready...")
     
-    # Wait for PostgreSQL - try both possible container names
+    # Wait for PostgreSQL
     for i in range(30):  # Wait up to 30 seconds
         try:
-            # Try the memra-ops container name first
-            result = subprocess.run([
-                'docker', 'exec', 'memra-ops_postgres_1', 
-                'pg_isready', '-U', 'postgres', '-d', 'local_workflow'
-            ], capture_output=True, text=True)
-            
-            if result.returncode == 0:
-                print("✅ PostgreSQL is ready")
-                break
-        except:
-            pass
-        
-        try:
-            # Fallback to the old container name
             result = subprocess.run([
                 'docker', 'exec', 'memra_postgres', 
                 'pg_isready', '-U', 'postgres', '-d', 'local_workflow'
@@ -694,101 +269,17 @@ def wait_for_services():
 def run_etl_workflow(demo_dir):
     """Run the ETL workflow"""
     try:
-        # Try to run the real ETL demo first
-        real_demo_script = demo_dir / "etl_invoice_demo.py"
-        if real_demo_script.exists():
-            print("🎯 Running real ETL workflow...")
-            print(f"📁 Working directory: {demo_dir}")
-            print(f"📄 Demo script: {real_demo_script}")
-            
-            # Check if data directory exists
-            data_dir = demo_dir / "data"
-            invoices_dir = data_dir / "invoices"
-            if invoices_dir.exists():
-                pdf_files = list(invoices_dir.glob("*.PDF"))
-                print(f"📊 Found {len(pdf_files)} PDF files in {invoices_dir}")
-                if pdf_files:
-                    print(f"   First few files: {[f.name for f in pdf_files[:3]]}")
-            else:
-                print(f"⚠️  Warning: {invoices_dir} does not exist")
-                print(f"   Available directories in {demo_dir}:")
-                for item in demo_dir.iterdir():
-                    if item.is_dir():
-                        print(f"     - {item.name}/")
-            
-            print("⏱️  Processing 15 files with delays - this may take 10-15 minutes")
-            
-            # Set the working directory to the demo directory so the script can find data/invoices/
-            result = subprocess.run(
-                [sys.executable, str(real_demo_script)], 
-                cwd=demo_dir,  # This is crucial - sets working directory
-                timeout=1800   # 30 minute timeout
-            )
+        # Run the demo script
+        demo_script = demo_dir / "etl_demo.py"
+        if demo_script.exists():
+            result = subprocess.run([sys.executable, str(demo_script)], cwd=demo_dir)
             return result.returncode == 0
         else:
-            # Fallback to simplified demo
-            demo_script = demo_dir / "etl_demo.py"
-            if demo_script.exists():
-                print("🎯 Running simplified demo...")
-                result = subprocess.run([sys.executable, str(demo_script)], cwd=demo_dir)
-                return result.returncode == 0
-            else:
-                print("❌ No demo script found")
-                print(f"   Looking for: {real_demo_script}")
-                print(f"   Available files in {demo_dir}:")
-                for item in demo_dir.iterdir():
-                    print(f"     - {item.name}")
-                return False
-            
-    except subprocess.TimeoutExpired:
-        print("⏰ ETL workflow timed out after 30 minutes")
-        print("This is normal for large batches - the demo processes 15 files with delays")
-        return False
-    except Exception as e:
-        print(f"❌ Error running ETL workflow: {e}")
-        return False
-
-def start_mcp_bridge_server(demo_dir):
-    """Start the MCP bridge server"""
-    try:
-        ops_dir = demo_dir / "memra-ops"
-        bridge_script = ops_dir / "mcp_bridge_server.py"
-        
-        if not bridge_script.exists():
-            print("❌ MCP bridge server script not found")
+            print("❌ Demo script not found")
             return False
-        
-        # Start the bridge server in the background
-        if os.name == 'nt':  # Windows
-            # Use start command to run in background
-            result = subprocess.run([
-                'start', '/B', 'python', str(bridge_script)
-            ], cwd=ops_dir, shell=True, capture_output=True, text=True)
-        else:  # Unix/Linux/Mac
-            result = subprocess.run([
-                'python', str(bridge_script)
-            ], cwd=ops_dir, start_new_session=True, capture_output=True, text=True)
-        
-        # Wait a moment for the server to start
-        time.sleep(3)
-        
-        # Check if the server is responding
-        try:
-            import requests
-            response = requests.get('http://localhost:8081/health', timeout=5)
-            if response.status_code == 200:
-                print("✅ MCP bridge server started successfully")
-                return True
-            else:
-                print(f"⚠️  MCP bridge server responded with status {response.status_code}")
-                return False
-        except Exception as e:
-            print(f"⚠️  Could not verify MCP bridge server: {e}")
-            print("   Server may still be starting up...")
-            return True  # Assume it's working
             
     except Exception as e:
-        print(f"❌ Error starting MCP bridge server: {e}")
+        print(f"❌ Error running ETL workflow: {e}")
         return False
 
 def main():

memra/demos/etl_invoice_processing/etl_invoice_demo.py

@@ -791,8 +791,10 @@ def process_database_insertion(agent, tool_results, **kwargs):
                 # Inject the properly formatted data into the tool parameters
                 if 'parameters' not in result:
                     result['parameters'] = {}
-                result['parameters']['data'] = db_data
-                print(f"\n✅ [AGENT 4] Injected transformed data into PostgresInsert parameters")
+                # Pass the data in the format expected by PostgresInsert tool
+                result['parameters']['invoice_data'] = invoice_data  # Pass the original invoice_data
+                result['parameters']['table_name'] = 'invoices'
+                print(f"\n✅ [AGENT 4] Injected invoice_data into PostgresInsert parameters")
     
     # Call the original print function for debugging
     print_database_data(agent, tool_results, invoice_data)

{memra-0.2.15.dist-info → memra-0.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: memra
-Version: 0.2.15
+Version: 0.2.16
 Summary: Declarative framework for enterprise workflows with MCP integration - Client SDK
 Home-page: https://github.com/memra/memra-sdk
 Author: Memra
@@ -20,18 +20,22 @@ 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'
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "mcp"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
 
 # Memra SDK
 

{memra-0.2.15.dist-info → memra-0.2.16.dist-info}/RECORD

@@ -1,5 +1,5 @@
-memra/__init__.py,sha256=6i82jodsWZPgtRhUaDF3wuQuRDSaboIpew8D3zDN__s,1109
-memra/cli.py,sha256=_IlOrTBlv_zBElxxQs13JYsdAuOn9wO1UiogmnwO1Qg,29430
+memra/__init__.py,sha256=DEOu1dmnPnJWyfCgmarnjSFZZSgiUiv3VdGA7thdxYs,1109
+memra/cli.py,sha256=DSkgwlko8NqUMdXxt-_Y7hMdqMGkGmF6PuzhQqCyjto,10310
 memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
 memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
 memra/execution.py,sha256=OXpBKxwBIjhACWL_qh8KHNndO8HUgB6gBF81AiQBBm0,34751
@@ -12,7 +12,7 @@ memra/demos/etl_invoice_processing/check_recent_db.py,sha256=tyO47DfwJkFH6IsdoM7
 memra/demos/etl_invoice_processing/database_monitor_agent.py,sha256=_A2mqweJTDOtbf57GCt20F5JG8RoH2UyUxET104dgAI,3497
 memra/demos/etl_invoice_processing/debug_mcp.py,sha256=xga1xzI0wycqF7aF5dsp3bL_o8aTnBYjOH0ZnjUZUtM,2066
 memra/demos/etl_invoice_processing/debug_schema.py,sha256=zirxgrgEtvE56oLNXvk4rL_kopIT53fIviKUQg1Ise4,1416
-memra/demos/etl_invoice_processing/etl_invoice_demo.py,sha256=6wVEAS8OMKwy4EPvDKoCov0r0QmgnfJ_Xz8zAs75haU,52813
+memra/demos/etl_invoice_processing/etl_invoice_demo.py,sha256=_ogkYQpiG95a1Sc-JCgjP9zRp8HbPQL_wlc2LHIFXCE,52998
 memra/demos/etl_invoice_processing/modify_database.py,sha256=qHzBf8ukeHouaOsy0kjsfR00xCbvPUOrt1gwc4y7Xkc,1939
 memra/demos/etl_invoice_processing/run_etl_batch.py,sha256=czX-gfUuVnYb1ZjzirK7w9aa1fAUuIRCs3044AucT_Y,1928
 memra/demos/etl_invoice_processing/setup_demo_data.py,sha256=aeOZtFBBl5SZFZ5IqM35Tcc_PjEJHuc2cfY_LRWXkBM,4875
@@ -58,9 +58,9 @@ memra/demos/etl_invoice_processing/data/invoices/10352262702.PDF,sha256=aNWnxbYq
 memra/demos/etl_invoice_processing/data/invoices/10352262884.PDF,sha256=G0eszEhpTOS15hIlMyPMM6iyVw6UZPKycXvS3P42xRc,1010830
 memra/demos/etl_invoice_processing/data/invoices/10352263346.PDF,sha256=NMfsgrmaNtvNu6xk2aLtubI05I9cuVIbwJMxv_pYPhQ,1089624
 memra/demos/etl_invoice_processing/data/invoices/10352263429.PDF,sha256=1IzJbmnsKDE1cV6CtyNMENn0Rmpq2tA_BDnZYTYhNhQ,1082893
-memra-0.2.15.dist-info/LICENSE,sha256=8OrnTd8DWwLWmUEj5srSLvT4PREfW1Qo1T5gEUIHPws,1062
-memra-0.2.15.dist-info/METADATA,sha256=-a6F6PGuriDeFNJjtGn30f0XFdt64O1pmkZjKwvzCB8,9427
-memra-0.2.15.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-memra-0.2.15.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
-memra-0.2.15.dist-info/top_level.txt,sha256=pXWcTRS1zctdiSUivW4iyKpJ4tcfIu-1BW_fpbal3OY,6
-memra-0.2.15.dist-info/RECORD,,
+memra-0.2.16.dist-info/licenses/LICENSE,sha256=8OrnTd8DWwLWmUEj5srSLvT4PREfW1Qo1T5gEUIHPws,1062
+memra-0.2.16.dist-info/METADATA,sha256=u-MAjWfwdJ9f79TA7SSGouLxrKm-RDkX12GsXR-HnXI,9497
+memra-0.2.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+memra-0.2.16.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
+memra-0.2.16.dist-info/top_level.txt,sha256=pXWcTRS1zctdiSUivW4iyKpJ4tcfIu-1BW_fpbal3OY,6
+memra-0.2.16.dist-info/RECORD,,

{memra-0.2.15.dist-info → memra-0.2.16.dist-info}/WHEEL

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