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

memra-ops/scripts/stop_memra.py

@@ -1,132 +0,0 @@
-#!/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() 

memra-ops/server_tool_registry.py

@@ -1,190 +0,0 @@
-import importlib
-import logging
-import sys
-import os
-from typing import Dict, Any, List, Optional, Callable
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-class ServerToolRegistry:
-    """Server-side registry for managing and executing tools from logic directory"""
-    
-    def __init__(self):
-        self.tools: Dict[str, Dict[str, Any]] = {}
-        self._add_project_to_path()
-        self._load_builtin_tools()
-    
-    def _add_project_to_path(self):
-        """Add the project root to Python path so we can import logic modules"""
-        # Get the directory containing this file (project root)
-        current_dir = Path(__file__).parent
-        
-        if str(current_dir) not in sys.path:
-            sys.path.insert(0, str(current_dir))
-    
-    def _load_builtin_tools(self):
-        """Load tools from the logic directory"""
-        try:
-            # Load invoice tools
-            from logic.invoice_tools import (
-                DatabaseQueryTool, PDFProcessor, OCRTool, 
-                InvoiceExtractionWorkflow, DataValidator, PostgresInsert
-            )
-            
-            self.register_tool("DatabaseQueryTool", DatabaseQueryTool, "memra", 
-                             "Query database schemas and data")
-            self.register_tool("PDFProcessor", PDFProcessor, "memra", 
-                             "Process PDF files and extract content")
-            self.register_tool("OCRTool", OCRTool, "memra", 
-                             "Perform OCR on images and documents")
-            self.register_tool("InvoiceExtractionWorkflow", InvoiceExtractionWorkflow, "memra", 
-                             "Extract structured data from invoices")
-            self.register_tool("DataValidator", DataValidator, "memra", 
-                             "Validate data against schemas")
-            self.register_tool("PostgresInsert", PostgresInsert, "memra", 
-                             "Insert data into PostgreSQL database")
-            
-            # Load file tools
-            from logic.file_tools import FileReader
-            self.register_tool("FileReader", FileReader, "memra", 
-                             "Read files from the filesystem")
-            
-            logger.info(f"Loaded {len(self.tools)} builtin tools")
-            
-        except ImportError as e:
-            logger.warning(f"Could not load some tools: {e}")
-    
-    def register_tool(self, name: str, tool_class: type, hosted_by: str, description: str):
-        """Register a tool in the registry"""
-        self.tools[name] = {
-            "class": tool_class,
-            "hosted_by": hosted_by,
-            "description": description
-        }
-        logger.debug(f"Registered tool: {name} (hosted by {hosted_by})")
-    
-    def discover_tools(self, hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
-        """Discover available tools, optionally filtered by host"""
-        tools = []
-        for name, info in self.tools.items():
-            if hosted_by is None or info["hosted_by"] == hosted_by:
-                tools.append({
-                    "name": name,
-                    "hosted_by": info["hosted_by"],
-                    "description": info["description"]
-                })
-        return tools
-    
-    def execute_tool(self, tool_name: str, hosted_by: str, input_data: Dict[str, Any], 
-                    config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Execute a tool with the given input data"""
-        if tool_name not in self.tools:
-            return {
-                "success": False,
-                "error": f"Tool '{tool_name}' not found in registry"
-            }
-        
-        tool_info = self.tools[tool_name]
-        if tool_info["hosted_by"] != hosted_by:
-            return {
-                "success": False,
-                "error": f"Tool '{tool_name}' is hosted by '{tool_info['hosted_by']}', not '{hosted_by}'"
-            }
-        
-        try:
-            # Instantiate tool
-            tool_class = tool_info["class"]
-            
-            # Some tools need credentials/config for initialization
-            if tool_name in ["DatabaseQueryTool", "PostgresInsert"]:
-                if "connection" in input_data:
-                    # Parse connection string or use credentials
-                    credentials = self._parse_connection(input_data["connection"])
-                    tool_instance = tool_class(credentials)
-                else:
-                    return {
-                        "success": False,
-                        "error": f"Tool '{tool_name}' requires database credentials"
-                    }
-            elif tool_name == "InvoiceExtractionWorkflow":
-                # This tool needs to be instantiated to initialize the LLM client
-                tool_instance = tool_class()
-            else:
-                tool_instance = tool_class()
-            
-            # Execute tool based on its type
-            result = self._execute_tool_method(tool_instance, tool_name, input_data, config)
-            
-            return {
-                "success": True,
-                "data": result
-            }
-            
-        except Exception as e:
-            logger.error(f"Tool execution failed for {tool_name}: {str(e)}")
-            return {
-                "success": False,
-                "error": str(e)
-            }
-    
-    def _execute_tool_method(self, tool_instance: Any, tool_name: str, 
-                           input_data: Dict[str, Any], config: Optional[Dict[str, Any]]) -> Dict[str, Any]:
-        """Execute the appropriate method on the tool instance"""
-        
-        if tool_name == "DatabaseQueryTool":
-            return tool_instance.get_schema("invoices")  # Default to invoices table
-        
-        elif tool_name == "PDFProcessor":
-            file_path = input_data.get("file", "")
-            # Handle both "schema" and "invoice_schema" keys
-            schema = input_data.get("schema") or input_data.get("invoice_schema", {})
-            return tool_instance.process_pdf(file_path, schema)
-        
-        elif tool_name == "OCRTool":
-            # Assume PDF processor output is passed as input
-            return {"extracted_text": tool_instance.extract_text(input_data)}
-        
-        elif tool_name == "InvoiceExtractionWorkflow":
-            text = input_data.get("extracted_text", "")
-            schema = input_data.get("invoice_schema", {})
-            return tool_instance.extract_data(text, schema)
-        
-        elif tool_name == "DataValidator":
-            data = input_data.get("invoice_data", {})
-            schema = input_data.get("invoice_schema", {})
-            return tool_instance.validate(data, schema)
-        
-        elif tool_name == "PostgresInsert":
-            data = input_data.get("invoice_data", {})
-            return tool_instance.insert_record("invoices", data)
-        
-        elif tool_name == "FileReader":
-            file_path = config.get("path") if config else input_data.get("file_path")
-            if not file_path:
-                raise ValueError("FileReader requires a file path")
-            return tool_instance.read_file(file_path)
-        
-        else:
-            raise ValueError(f"Unknown tool execution method for {tool_name}")
-    
-    def _parse_connection(self, connection_string: str) -> Dict[str, Any]:
-        """Parse a connection string into credentials"""
-        # Simple parser for postgres://user:pass@host:port/database
-        if connection_string.startswith("postgres://"):
-            # This is a simplified parser - in production you'd use a proper URL parser
-            parts = connection_string.replace("postgres://", "").split("/")
-            db_part = parts[1] if len(parts) > 1 else "finance"
-            auth_host = parts[0].split("@")
-            host_port = auth_host[1].split(":") if len(auth_host) > 1 else ["localhost", "5432"]
-            user_pass = auth_host[0].split(":") if len(auth_host) > 1 else ["user", "pass"]
-            
-            return {
-                "host": host_port[0],
-                "port": int(host_port[1]) if len(host_port) > 1 else 5432,
-                "database": db_part,
-                "user": user_pass[0],
-                "password": user_pass[1] if len(user_pass) > 1 else ""
-            }
-        
-        return {"connection_string": connection_string} 

memra-ops/tests/test_llm_text_to_sql.py

@@ -1,115 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify LLM-based text-to-SQL generation
-"""
-
-import requests
-import json
-import time
-
-def test_llm_text_to_sql():
-    """Test the new LLM-based text-to-SQL generation"""
-    bridge_url = "http://localhost:8081"
-    bridge_secret = "test-secret-for-development"
-    
-    # Test questions to verify LLM vs pattern matching
-    test_questions = [
-        "Show me all invoices from Air Liquide",
-        "What is the total amount of all invoices?",
-        "How many invoices do we have?",
-        "Show me the 3 most recent invoices",
-        "What is the average invoice amount?",
-        "Find invoices with amounts greater than 1000",  # This should test LLM capabilities
-        "Show me invoices from last month",  # This should test LLM capabilities
-        "Which vendor has the highest total invoice amount?"  # Complex query for LLM
-    ]
-    
-    # Schema info for context
-    schema_info = {
-        "schema": {
-            "invoices": {
-                "columns": [
-                    {"name": "id", "type": "integer"},
-                    {"name": "vendor_name", "type": "text"},
-                    {"name": "invoice_number", "type": "text"},
-                    {"name": "invoice_date", "type": "date"},
-                    {"name": "total_amount", "type": "numeric"},
-                    {"name": "tax_amount", "type": "numeric"},
-                    {"name": "line_items", "type": "jsonb"},
-                    {"name": "status", "type": "text"}
-                ]
-            }
-        }
-    }
-    
-    headers = {
-        "Content-Type": "application/json",
-        "X-Bridge-Secret": bridge_secret
-    }
-    
-    print("🧪 Testing LLM-based Text-to-SQL Generation")
-    print("=" * 60)
-    
-    for i, question in enumerate(test_questions, 1):
-        print(f"\n🎯 Test {i}: {question}")
-        print("-" * 50)
-        
-        # Prepare request
-        request_data = {
-            "tool_name": "TextToSQLGenerator",
-            "input_data": {
-                "question": question,
-                "schema_info": schema_info
-            }
-        }
-        
-        try:
-            start_time = time.time()
-            
-            # Make request to MCP bridge
-            response = requests.post(
-                f"{bridge_url}/execute_tool",
-                json=request_data,
-                headers=headers,
-                timeout=30  # Longer timeout for LLM calls
-            )
-            
-            end_time = time.time()
-            duration = end_time - start_time
-            
-            if response.status_code == 200:
-                result = response.json()
-                
-                if result.get("success"):
-                    data = result.get("data", {})
-                    sql_query = data.get("generated_sql", "")
-                    explanation = data.get("explanation", "")
-                    confidence = data.get("confidence", "unknown")
-                    method = data.get("method", "unknown")
-                    
-                    print(f"✅ Success ({duration:.1f}s)")
-                    print(f"📝 SQL: {sql_query}")
-                    print(f"💡 Method: {method}")
-                    print(f"🎯 Confidence: {confidence}")
-                    print(f"📖 Explanation: {explanation}")
-                    
-                    # Highlight if this is using LLM
-                    if method == "llm":
-                        print("🚀 Using LLM generation!")
-                    elif method == "pattern_matching":
-                        print("⚠️  Fallback to pattern matching")
-                    
-                else:
-                    print(f"❌ Failed: {result.get('error', 'Unknown error')}")
-                    
-            else:
-                print(f"❌ HTTP Error: {response.status_code}")
-                print(f"Response: {response.text}")
-                
-        except Exception as e:
-            print(f"❌ Exception: {str(e)}")
-    
-    print(f"\n✨ LLM Text-to-SQL testing completed!")
-
-if __name__ == "__main__":
-    test_llm_text_to_sql() 

memra-ops/tests/test_llm_vs_pattern.py

@@ -1,130 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to demonstrate LLM vs Pattern Matching for text-to-SQL
-"""
-
-import requests
-import json
-import time
-
-def test_query(question, description=""):
-    """Test a single query and return results"""
-    bridge_url = "http://localhost:8081"
-    bridge_secret = "test-secret-for-development"
-    
-    schema_info = {
-        "schema": {
-            "invoices": {
-                "columns": [
-                    {"name": "id", "type": "integer"},
-                    {"name": "vendor_name", "type": "text"},
-                    {"name": "invoice_number", "type": "text"},
-                    {"name": "invoice_date", "type": "date"},
-                    {"name": "total_amount", "type": "numeric"},
-                    {"name": "tax_amount", "type": "numeric"},
-                    {"name": "line_items", "type": "jsonb"},
-                    {"name": "status", "type": "text"}
-                ]
-            }
-        }
-    }
-    
-    headers = {
-        "Content-Type": "application/json",
-        "X-Bridge-Secret": bridge_secret
-    }
-    
-    request_data = {
-        "tool_name": "TextToSQLGenerator",
-        "input_data": {
-            "question": question,
-            "schema_info": schema_info
-        }
-    }
-    
-    print(f"\n🎯 {description}")
-    print(f"❓ Question: {question}")
-    print("-" * 60)
-    
-    try:
-        start_time = time.time()
-        
-        response = requests.post(
-            f"{bridge_url}/execute_tool",
-            json=request_data,
-            headers=headers,
-            timeout=30
-        )
-        
-        end_time = time.time()
-        duration = end_time - start_time
-        
-        if response.status_code == 200:
-            result = response.json()
-            
-            if result.get("success"):
-                data = result.get("data", {})
-                sql_query = data.get("generated_sql", "")
-                method = data.get("method", "unknown")
-                confidence = data.get("confidence", "unknown")
-                
-                print(f"✅ Success ({duration:.1f}s)")
-                print(f"📝 SQL: {sql_query}")
-                print(f"💡 Method: {method}")
-                print(f"🎯 Confidence: {confidence}")
-                
-                if method == "llm":
-                    print("🚀 LLM Generation - Advanced natural language understanding!")
-                elif method == "pattern_matching":
-                    print("⚙️  Pattern Matching - Rule-based fallback")
-                else:
-                    print("❓ Unknown method")
-                
-                return True
-            else:
-                print(f"❌ Failed: {result.get('error', 'Unknown error')}")
-                return False
-        else:
-            print(f"❌ HTTP Error: {response.status_code}")
-            return False
-            
-    except Exception as e:
-        print(f"❌ Exception: {str(e)}")
-        return False
-
-def main():
-    """Test various queries to demonstrate LLM capabilities"""
-    print("🧪 LLM vs Pattern Matching Text-to-SQL Comparison")
-    print("=" * 70)
-    
-    # Test cases that should showcase LLM capabilities
-    test_cases = [
-        ("Show me all invoices from Air Liquide", "Simple vendor filtering (both methods can handle)"),
-        ("Find invoices with amounts greater than 1000", "Numeric comparison (LLM advantage)"),
-        ("Show me invoices from last month", "Date range query (LLM advantage)"),
-        ("Which vendor has the highest total invoice amount?", "Complex aggregation with grouping (LLM advantage)"),
-        ("Find invoices where the tax amount is more than 10% of total", "Complex calculation (LLM advantage)"),
-        ("Show me all pending invoices sorted by amount", "Status filtering with sorting (LLM advantage)"),
-        ("What is the average invoice amount?", "Simple aggregation (both methods can handle)"),
-        ("List all unique vendors", "Distinct query (both methods can handle)"),
-        ("Find invoices with line items containing 'software'", "JSON field querying (LLM advantage)"),
-        ("Show me the top 5 vendors by total invoice value", "Complex grouping and ranking (LLM advantage)")
-    ]
-    
-    success_count = 0
-    llm_count = 0
-    pattern_count = 0
-    
-    for question, description in test_cases:
-        if test_query(question, description):
-            success_count += 1
-            # Note: We'd need to parse the response to count methods accurately
-    
-    print(f"\n✨ Testing completed!")
-    print(f"📊 {success_count}/{len(test_cases)} queries successful")
-    print(f"\n🎉 The LLM-based text-to-SQL system is now active!")
-    print(f"🔄 It automatically falls back to pattern matching if LLM fails")
-    print(f"🚀 Complex queries now benefit from advanced natural language understanding")
-
-if __name__ == "__main__":
-    main()