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

memra-ops/config/config.py

@@ -0,0 +1,25 @@
+"""
+Configuration for Memra SDK examples
+Contains LLM configurations for different agent types
+"""
+
+# Default LLM configuration for general use
+DEFAULT_LLM_CONFIG = {
+    "model": "llama-3.2-11b-vision-preview",
+    "temperature": 0.1,
+    "max_tokens": 2000
+}
+
+# Specialized LLM configurations for different agent types
+AGENT_LLM_CONFIG = {
+    "parsing": {
+        "model": "llama-3.2-11b-vision-preview",
+        "temperature": 0.0,
+        "max_tokens": 4000
+    },
+    "manager": {
+        "model": "llama-3.2-11b-vision-preview", 
+        "temperature": 0.2,
+        "max_tokens": 1000
+    }
+} 

memra-ops/config.py

@@ -0,0 +1,34 @@
+# Memra SDK Configuration
+# LLM API Configuration for agent processing
+
+API_CONFIG = {
+    "huggingface": {
+        "api_key": "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",
+        "model": "meta-llama/Llama-4-Maverick-17B-128E-Instruct",
+        "max_tokens": 2000
+    }
+}
+
+# Default LLM settings for agents
+DEFAULT_LLM_CONFIG = {
+    "provider": "huggingface",
+    "model": "meta-llama/Llama-4-Maverick-17B-128E-Instruct",
+    "temperature": 0.1,
+    "max_tokens": 2000
+}
+
+# Agent-specific LLM configurations
+AGENT_LLM_CONFIG = {
+    "parsing": {
+        "provider": "huggingface", 
+        "model": "meta-llama/Llama-4-Maverick-17B-128E-Instruct",
+        "temperature": 0.0,  # More deterministic for data extraction
+        "max_tokens": 2000
+    },
+    "manager": {
+        "provider": "huggingface",
+        "model": "meta-llama/Llama-4-Maverick-17B-128E-Instruct", 
+        "temperature": 0.3,  # More flexible for decision making
+        "max_tokens": 1500
+    }
+} 

memra-ops/scripts/release.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+Release script for Memra SDK
+Builds and uploads the package to PyPI
+"""
+
+import os
+import sys
+import subprocess
+import shutil
+from pathlib import Path
+
+def run_command(cmd, description):
+    """Run a command and handle errors"""
+    print(f"🔄 {description}...")
+    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"❌ {description} failed:")
+        print(result.stderr)
+        sys.exit(1)
+    print(f"✅ {description} completed")
+    return result.stdout
+
+def clean_build_artifacts():
+    """Clean up build artifacts"""
+    print("🧹 Cleaning build artifacts...")
+    
+    # Remove build directories
+    for dir_name in ['build', 'dist', 'memra.egg-info']:
+        if os.path.exists(dir_name):
+            shutil.rmtree(dir_name)
+            print(f"   Removed {dir_name}/")
+    
+    # Remove __pycache__ directories
+    for root, dirs, files in os.walk('.'):
+        for dir_name in dirs:
+            if dir_name == '__pycache__':
+                pycache_path = os.path.join(root, dir_name)
+                shutil.rmtree(pycache_path)
+                print(f"   Removed {pycache_path}")
+    
+    print("✅ Build artifacts cleaned")
+
+def run_tests():
+    """Run tests before release"""
+    print("🧪 Running tests...")
+    
+    # Check if pytest is available
+    try:
+        subprocess.run(['pytest', '--version'], check=True, capture_output=True)
+        run_command('pytest tests/', 'Running pytest')
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("⚠️  pytest not found, skipping tests")
+    
+    # Run basic import test
+    run_command('python -c "import memra; print(f\'Memra SDK version: {memra.__version__ if hasattr(memra, \"__version__\") else \"unknown\"}\')"', 'Testing basic import')
+
+def build_package():
+    """Build the package"""
+    print("📦 Building package...")
+    
+    # Install build dependencies
+    run_command('pip install build twine', 'Installing build tools')
+    
+    # Build the package
+    run_command('python -m build', 'Building wheel and source distribution')
+    
+    # Check the package
+    run_command('twine check dist/*', 'Checking package')
+
+def upload_package(test=False):
+    """Upload package to PyPI"""
+    if test:
+        print("🚀 Uploading to Test PyPI...")
+        run_command('twine upload --repository testpypi dist/*', 'Uploading to Test PyPI')
+        print("📍 Package uploaded to Test PyPI: https://test.pypi.org/project/memra/")
+    else:
+        print("🚀 Uploading to PyPI...")
+        run_command('twine upload dist/*', 'Uploading to PyPI')
+        print("📍 Package uploaded to PyPI: https://pypi.org/project/memra/")
+
+def main():
+    """Main release process"""
+    print("🎯 Memra SDK Release Process")
+    print("=" * 40)
+    
+    # Parse arguments
+    test_release = '--test' in sys.argv
+    skip_tests = '--skip-tests' in sys.argv
+    
+    if test_release:
+        print("🧪 Test release mode enabled")
+    
+    # Ensure we're in the right directory
+    if not os.path.exists('setup.py'):
+        print("❌ setup.py not found. Please run from the project root.")
+        sys.exit(1)
+    
+    try:
+        # Clean up
+        clean_build_artifacts()
+        
+        # Run tests
+        if not skip_tests:
+            run_tests()
+        else:
+            print("⚠️  Skipping tests")
+        
+        # Build package
+        build_package()
+        
+        # Upload package
+        upload_package(test=test_release)
+        
+        print("\n🎉 Release completed successfully!")
+        
+        if test_release:
+            print("\n📋 Next steps:")
+            print("1. Test the package: pip install -i https://test.pypi.org/simple/ memra")
+            print("2. If everything works, run: python scripts/release.py")
+        else:
+            print("\n📋 Package is now available on PyPI!")
+            print("Install with: pip install memra")
+        
+    except KeyboardInterrupt:
+        print("\n❌ Release cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n❌ Release failed: {e}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main() 

memra-ops/scripts/start_memra.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""
+Memra System Startup Script
+Starts all dependencies required for the Memra system to run
+"""
+
+import os
+import sys
+import time
+import subprocess
+import requests
+import signal
+from pathlib import Path
+
+# Add the project root to the path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+class MemraStartup:
+    def __init__(self):
+        self.project_root = project_root
+        self.docker_compose_file = project_root / "docker-compose.yml"
+        self.mcp_bridge_script = project_root / "mcp_bridge_server.py"
+        self.processes = []
+        
+    def print_banner(self):
+        """Print startup banner"""
+        print("=" * 60)
+        print("🚀 MEMRA SYSTEM STARTUP")
+        print("=" * 60)
+        print("Starting all dependencies for Memra AI workflow system...")
+        print()
+        
+    def check_conda_environment(self):
+        """Check if we're in the correct conda environment"""
+        print("🔍 Checking conda environment...")
+        
+        # Check if we're in the memra environment
+        conda_env = os.getenv('CONDA_DEFAULT_ENV')
+        if conda_env != 'memra':
+            print(f"❌ Warning: Not in 'memra' conda environment (current: {conda_env})")
+            print("   Please run: conda activate memra")
+            print("   Then run this script again.")
+            return False
+        
+        print(f"✅ Conda environment: {conda_env}")
+        return True
+        
+    def check_docker(self):
+        """Check if Docker is running"""
+        print("🐳 Checking Docker...")
+        try:
+            result = subprocess.run(['docker', 'info'], 
+                                  capture_output=True, text=True, timeout=10)
+            if result.returncode == 0:
+                print("✅ Docker is running")
+                return True
+            else:
+                print("❌ Docker is not running")
+                return False
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            print("❌ Docker is not running or not installed")
+            return False
+            
+    def start_postgresql(self):
+        """Start PostgreSQL using Docker Compose"""
+        print("🐘 Starting PostgreSQL...")
+        
+        try:
+            # Check if containers are already running
+            result = subprocess.run(['docker', 'ps', '--filter', 'name=memra-postgres'], 
+                                  capture_output=True, text=True)
+            
+            if 'memra-postgres' in result.stdout:
+                print("✅ PostgreSQL is already running")
+                return True
+                
+            # Start PostgreSQL
+            print("   Starting PostgreSQL container...")
+            result = subprocess.run(['docker-compose', 'up', '-d', 'postgres'], 
+                                  cwd=self.project_root, capture_output=True, text=True)
+            
+            if result.returncode == 0:
+                print("✅ PostgreSQL started successfully")
+                return True
+            else:
+                print(f"❌ Failed to start PostgreSQL: {result.stderr}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error starting PostgreSQL: {e}")
+            return False
+            
+    def wait_for_postgresql(self, max_attempts=30):
+        """Wait for PostgreSQL to be ready"""
+        print("⏳ Waiting for PostgreSQL to be ready...")
+        
+        for attempt in range(max_attempts):
+            try:
+                # Try to connect to PostgreSQL
+                result = subprocess.run([
+                    'docker', 'exec', 'memra-postgres', 
+                    'pg_isready', '-U', 'memra', '-d', 'memra_invoice_db'
+                ], capture_output=True, text=True, timeout=5)
+                
+                if result.returncode == 0:
+                    print("✅ PostgreSQL is ready")
+                    return True
+                    
+            except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+                pass
+                
+            print(f"   Attempt {attempt + 1}/{max_attempts}...")
+            time.sleep(2)
+            
+        print("❌ PostgreSQL failed to start within timeout")
+        return False
+        
+    def check_memra_api_key(self):
+        """Check if MEMRA_API_KEY is set"""
+        print("🔑 Checking Memra API key...")
+        
+        api_key = os.getenv('MEMRA_API_KEY')
+        if not api_key:
+            print("❌ MEMRA_API_KEY environment variable is not set")
+            print("   Please set: export MEMRA_API_KEY='your-key-here'")
+            return False
+            
+        print(f"✅ Memra API key is set: {api_key[:8]}...")
+        return True
+        
+    def start_mcp_bridge(self):
+        """Start the MCP bridge server"""
+        print("🌉 Starting MCP Bridge Server...")
+        
+        try:
+            # Check if MCP bridge is already running
+            try:
+                response = requests.get('http://localhost:8081/health', timeout=5)
+                if response.status_code == 200:
+                    print("✅ MCP Bridge Server is already running")
+                    return True
+            except requests.RequestException:
+                pass
+                
+            # Start MCP bridge server in background
+            print("   Starting MCP bridge server...")
+            process = subprocess.Popen([
+                sys.executable, str(self.mcp_bridge_script)
+            ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            self.processes.append(process)
+            
+            # Wait a moment for server to start
+            time.sleep(3)
+            
+            # Check if server started successfully
+            try:
+                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 returned status {response.status_code}")
+                    return False
+            except requests.RequestException as e:
+                print(f"❌ MCP Bridge Server failed to start: {e}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error starting MCP Bridge Server: {e}")
+            return False
+            
+    def test_memra_api(self):
+        """Test the Memra API connection"""
+        print("🌐 Testing Memra API connection...")
+        
+        try:
+            from memra import get_api_status
+            api_status = get_api_status()
+            
+            if api_status['api_healthy']:
+                print(f"✅ Memra API is healthy")
+                print(f"   URL: {api_status['api_url']}")
+                print(f"   Tools Available: {api_status['tools_available']}")
+                return True
+            else:
+                print("❌ Memra API is not healthy")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error testing Memra API: {e}")
+            return False
+            
+    def run_test_workflow(self):
+        """Run a quick test to verify everything works"""
+        print("🧪 Running system test...")
+        
+        try:
+            # Import and run a simple test
+            from memra import Agent, Department, LLM
+            from memra.execution import ExecutionEngine
+            
+            # Create a simple test agent
+            test_agent = Agent(
+                role="Test Agent",
+                job="Verify system is working",
+                llm=LLM(model="llama-3.2-11b-vision-preview", temperature=0.1),
+                sops=["Return a simple success message"],
+                output_key="test_result"
+            )
+            
+            # Create test department
+            test_dept = Department(
+                name="Test Department",
+                mission="Verify Memra system is working",
+                agents=[test_agent],
+                workflow_order=["Test Agent"]
+            )
+            
+            # Run test
+            engine = ExecutionEngine()
+            result = engine.execute_department(test_dept, {})
+            
+            if result.success:
+                print("✅ System test passed - Memra is ready!")
+                return True
+            else:
+                print(f"❌ System test failed: {result.error}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error running system test: {e}")
+            return False
+            
+    def cleanup(self):
+        """Cleanup processes on exit"""
+        print("\n🧹 Cleaning up processes...")
+        for process in self.processes:
+            try:
+                process.terminate()
+                process.wait(timeout=5)
+            except:
+                try:
+                    process.kill()
+                except:
+                    pass
+                    
+    def signal_handler(self, signum, frame):
+        """Handle interrupt signals"""
+        print("\n🛑 Received interrupt signal, shutting down...")
+        self.cleanup()
+        sys.exit(0)
+        
+    def start(self):
+        """Main startup sequence"""
+        try:
+            self.print_banner()
+            
+            # Set up signal handlers
+            signal.signal(signal.SIGINT, self.signal_handler)
+            signal.signal(signal.SIGTERM, self.signal_handler)
+            
+            # Check environment
+            if not self.check_conda_environment():
+                return False
+                
+            # Check Docker
+            if not self.check_docker():
+                print("❌ Please start Docker Desktop and try again")
+                return False
+                
+            # Start PostgreSQL
+            if not self.start_postgresql():
+                return False
+                
+            if not self.wait_for_postgresql():
+                return False
+                
+            # Check API key
+            if not self.check_memra_api_key():
+                return False
+                
+            # Start MCP bridge
+            if not self.start_mcp_bridge():
+                return False
+                
+            # Test API
+            if not self.test_memra_api():
+                return False
+                
+            # Run system test
+            if not self.run_test_workflow():
+                return False
+                
+            print("\n" + "=" * 60)
+            print("🎉 MEMRA SYSTEM STARTED SUCCESSFULLY!")
+            print("=" * 60)
+            print("✅ All dependencies are running:")
+            print("   • PostgreSQL Database (Docker)")
+            print("   • MCP Bridge Server (localhost:8081)")
+            print("   • Memra API (https://api.memra.co)")
+            print()
+            print("🚀 Ready to run workflows!")
+            print("   Example: python3 examples/accounts_payable_client.py")
+            print()
+            print("💡 Keep this terminal open to maintain the MCP bridge server")
+            print("   Press Ctrl+C to stop all services")
+            print("=" * 60)
+            
+            # Keep the script running to maintain the MCP bridge server
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print("\n🛑 Shutting down Memra system...")
+                self.cleanup()
+                print("✅ Memra system stopped")
+                
+        except Exception as e:
+            print(f"❌ Startup failed: {e}")
+            self.cleanup()
+            return False
+            
+        return True
+
+def main():
+    """Main entry point"""
+    startup = MemraStartup()
+    success = startup.start()
+    sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+    main() 

memra-ops/scripts/stop_memra.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+Memra System Stop Script
+Gracefully stops all Memra system dependencies
+"""
+
+import os
+import sys
+import subprocess
+import requests
+import signal
+from pathlib import Path
+
+class MemraStop:
+    def __init__(self):
+        self.project_root = Path(__file__).parent.parent
+        
+    def print_banner(self):
+        """Print stop banner"""
+        print("=" * 60)
+        print("🛑 MEMRA SYSTEM SHUTDOWN")
+        print("=" * 60)
+        print("Stopping all Memra system dependencies...")
+        print()
+        
+    def stop_mcp_bridge(self):
+        """Stop the MCP bridge server"""
+        print("🌉 Stopping MCP Bridge Server...")
+        
+        try:
+            # Try to send a graceful shutdown signal
+            response = requests.get('http://localhost:8081/health', timeout=5)
+            if response.status_code == 200:
+                print("   MCP Bridge Server is running, stopping...")
+                
+                # Find and kill the MCP bridge process
+                result = subprocess.run(['pkill', '-f', 'mcp_bridge_server.py'], 
+                                      capture_output=True, text=True)
+                
+                if result.returncode == 0:
+                    print("✅ MCP Bridge Server stopped")
+                else:
+                    print("⚠️  MCP Bridge Server process not found (may already be stopped)")
+            else:
+                print("✅ MCP Bridge Server is not running")
+                
+        except requests.RequestException:
+            print("✅ MCP Bridge Server is not running")
+            
+    def stop_postgresql(self):
+        """Stop PostgreSQL using Docker Compose"""
+        print("🐘 Stopping PostgreSQL...")
+        
+        try:
+            # Check if PostgreSQL container is running
+            result = subprocess.run(['docker', 'ps', '--filter', 'name=memra-postgres'], 
+                                  capture_output=True, text=True)
+            
+            if 'memra-postgres' in result.stdout:
+                print("   PostgreSQL container is running, stopping...")
+                
+                # Stop PostgreSQL container
+                result = subprocess.run(['docker-compose', 'stop', 'postgres'], 
+                                      cwd=self.project_root, capture_output=True, text=True)
+                
+                if result.returncode == 0:
+                    print("✅ PostgreSQL stopped")
+                else:
+                    print(f"⚠️  Warning: Failed to stop PostgreSQL: {result.stderr}")
+            else:
+                print("✅ PostgreSQL is not running")
+                
+        except Exception as e:
+            print(f"⚠️  Warning: Error stopping PostgreSQL: {e}")
+            
+    def cleanup_docker(self):
+        """Clean up any orphaned Docker containers"""
+        print("🧹 Cleaning up Docker containers...")
+        
+        try:
+            # Remove any stopped containers
+            result = subprocess.run(['docker', 'container', 'prune', '-f'], 
+                                  capture_output=True, text=True)
+            
+            if result.returncode == 0:
+                print("✅ Docker containers cleaned up")
+            else:
+                print("⚠️  Warning: Failed to clean up Docker containers")
+                
+        except Exception as e:
+            print(f"⚠️  Warning: Error cleaning up Docker: {e}")
+            
+    def stop(self):
+        """Main stop sequence"""
+        try:
+            self.print_banner()
+            
+            # Stop MCP bridge server
+            self.stop_mcp_bridge()
+            
+            # Stop PostgreSQL
+            self.stop_postgresql()
+            
+            # Clean up Docker
+            self.cleanup_docker()
+            
+            print("\n" + "=" * 60)
+            print("✅ MEMRA SYSTEM STOPPED SUCCESSFULLY!")
+            print("=" * 60)
+            print("All services have been stopped:")
+            print("   • MCP Bridge Server")
+            print("   • PostgreSQL Database")
+            print("   • Docker containers cleaned up")
+            print()
+            print("💡 To start the system again, run:")
+            print("   ./scripts/start_memra.sh")
+            print("=" * 60)
+            
+        except Exception as e:
+            print(f"❌ Stop failed: {e}")
+            return False
+            
+        return True
+
+def main():
+    """Main entry point"""
+    stop = MemraStop()
+    success = stop.stop()
+    sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+    main()