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

memra-ops/tests/test_mcp_schema_aware.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python3
-"""
-Direct test of MCP bridge server schema-aware SQL generation
-"""
-
-import requests
-import json
-
-def test_schema_aware_sql():
-    """Test schema-aware SQL generation directly via MCP bridge"""
-    print("🧪 Testing Schema-Aware SQL Generation (Direct MCP)")
-    print("=" * 55)
-    
-    bridge_url = "http://localhost:8081"
-    bridge_secret = "test-secret-for-development"
-    
-    # First, get the schema information (simulated)
-    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": "line_items", "type": "jsonb"}
-                ]
-            }
-        }
-    }
-    
-    # Test questions
-    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?",
-        "Count invoices from Microsoft"
-    ]
-    
-    print(f"\n🔍 Testing {len(test_questions)} questions with schema context...")
-    
-    for i, question in enumerate(test_questions, 1):
-        print(f"\n--- Test {i}: {question} ---")
-        
-        # Prepare request data
-        request_data = {
-            "tool_name": "TextToSQLGenerator",
-            "input_data": {
-                "question": question,
-                "schema_info": schema_info
-            }
-        }
-        
-        headers = {
-            "Content-Type": "application/json",
-            "X-Bridge-Secret": bridge_secret
-        }
-        
-        try:
-            # Make request to MCP bridge
-            response = requests.post(
-                f"{bridge_url}/execute_tool",
-                json=request_data,
-                headers=headers,
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                
-                if result.get("success"):
-                    data = result.get("data", {})
-                    generated_sql = data.get("generated_sql", "")
-                    explanation = data.get("explanation", "")
-                    confidence = data.get("confidence", "unknown")
-                    schema_used = data.get("schema_used", {})
-                    
-                    print(f"✅ SQL Generated (confidence: {confidence})")
-                    print(f"   Query: {generated_sql}")
-                    print(f"   Explanation: {explanation}")
-                    
-                    if schema_used:
-                        columns = schema_used.get("columns", [])
-                        print(f"   Schema columns used: {', '.join(columns)}")
-                    
-                    # Check if SQL uses actual column names
-                    schema_columns = ["vendor_name", "total_amount", "invoice_date", "invoice_number"]
-                    uses_schema = any(col in generated_sql for col in schema_columns)
-                    
-                    if uses_schema:
-                        print("🎯 SQL appears to use actual schema column names!")
-                    else:
-                        print("⚠️  SQL might not be using schema information")
-                        
-                else:
-                    print(f"❌ SQL generation failed: {result.get('error')}")
-            else:
-                print(f"❌ HTTP error: {response.status_code}")
-                print(f"   Response: {response.text}")
-                
-        except Exception as e:
-            print(f"❌ Request failed: {str(e)}")
-    
-    print(f"\n✨ Schema-aware SQL generation test completed!")
-
-def main():
-    """Main function"""
-    try:
-        # Check if MCP bridge is running
-        response = requests.get("http://localhost:8081/health", timeout=5)
-        if response.status_code == 200:
-            print("✅ MCP Bridge server is running")
-            test_schema_aware_sql()
-        else:
-            print("❌ MCP Bridge server is not responding")
-    except Exception as e:
-        print(f"❌ Cannot connect to MCP Bridge server: {str(e)}")
-        print("💡 Make sure the MCP bridge server is running on port 8081")
-
-if __name__ == "__main__":
-    main() 

memra-ops/tests/test_schema_aware_sql.py

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify schema-aware SQL generation
-"""
-
-import sys
-import os
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from memra import ExecutionEngine, Agent, Tool
-
-def create_test_system():
-    """Create a test system with schema-aware SQL generation"""
-    
-    # Create execution engine
-    engine = ExecutionEngine()
-    
-    # Create schema agent
-    schema_agent = Agent(
-        role="database_schema_analyst", 
-        job="Extract and analyze database schema information for SQL generation",
-        output_key="schema_data",
-        tools=[
-            Tool(
-                name="SchemaExtractor",
-                hosted_by="memra",
-                config={
-                    "api_key": "memra-prod-2024-001"
-                }
-            )
-        ]
-    )
-    
-    # Create SQL generator agent with schema awareness
-    sql_generator_agent = Agent(
-        role="text_to_sql_converter",
-        job="Convert natural language questions to SQL using database schema context",
-        output_key="generated_sql",
-        tools=[
-            Tool(
-                name="TextToSQLGenerator",
-                hosted_by="mcp",
-                config={
-                    "mcp_bridge_url": "http://localhost:8081",
-                    "bridge_secret": "test-secret-for-development"
-                }
-            )
-        ]
-    )
-    
-    return engine, schema_agent, sql_generator_agent
-
-def test_schema_aware_sql_generation():
-    """Test that SQL generation uses schema information"""
-    print("🧪 Testing Schema-Aware SQL Generation")
-    print("=" * 50)
-    
-    engine, schema_agent, sql_generator_agent = create_test_system()
-    
-    # Step 1: Extract schema
-    print("\n1️⃣ Extracting database schema...")
-    schema_task = {
-        "task": "Extract the complete schema for the invoices table",
-        "table_name": "invoices",
-        "include_sample_data": True
-    }
-    
-    schema_result = engine.execute_task(schema_agent, schema_task)
-    
-    if not schema_result.get("success"):
-        print(f"❌ Schema extraction failed: {schema_result.get('error')}")
-        return
-    
-    schema_data = schema_result.get("result", {})
-    print(f"✅ Schema extracted successfully")
-    
-    # Display schema info
-    if "schema" in schema_data:
-        print("\n📊 Database Schema:")
-        schema = schema_data["schema"]
-        for table_name, table_info in schema.items():
-            print(f"  Table: {table_name}")
-            if "columns" in table_info:
-                for col in table_info["columns"]:
-                    print(f"    - {col['name']} ({col['type']})")
-    
-    # Step 2: Test various questions with schema context
-    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 5 most recent invoices",
-        "What is the average invoice amount?",
-        "Count invoices from Microsoft"
-    ]
-    
-    print(f"\n2️⃣ Testing SQL generation with schema context...")
-    
-    for i, question in enumerate(test_questions, 1):
-        print(f"\n--- Test {i}: {question} ---")
-        
-        sql_task = {
-            "question": question,
-            "schema_info": schema_data,
-            "context": "Generate SQL using provided schema information"
-        }
-        
-        sql_result = engine.execute_task(sql_generator_agent, sql_task)
-        
-        if sql_result.get("success"):
-            sql_data = sql_result.get("result", {})
-            generated_sql = sql_data.get("generated_sql", "")
-            explanation = sql_data.get("explanation", "")
-            confidence = sql_data.get("confidence", "unknown")
-            schema_used = sql_data.get("schema_used", {})
-            
-            print(f"✅ SQL Generated (confidence: {confidence})")
-            print(f"   Query: {generated_sql}")
-            print(f"   Explanation: {explanation}")
-            
-            if schema_used:
-                columns_used = schema_used.get("columns", [])
-                print(f"   Schema columns available: {', '.join(columns_used)}")
-        else:
-            print(f"❌ SQL generation failed: {sql_result.get('error')}")
-    
-    print(f"\n✨ Schema-aware SQL generation test completed!")
-
-def main():
-    """Main function"""
-    try:
-        test_schema_aware_sql_generation()
-    except KeyboardInterrupt:
-        print("\n\n⏹️  Test interrupted by user")
-    except Exception as e:
-        print(f"\n❌ Test failed with error: {str(e)}")
-
-if __name__ == "__main__":
-    main() 

memra-ops/tests/test_schema_aware_sql_simple.py

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple test to verify schema-aware SQL generation using the complete system
-"""
-
-import sys
-import os
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from examples.complete_text_to_sql_system import create_text_to_sql_system, run_text_to_sql_query
-
-def test_schema_awareness():
-    """Test that SQL generation properly uses schema information"""
-    print("🧪 Testing Schema-Aware SQL Generation")
-    print("=" * 50)
-    
-    # Create the complete system
-    engine, schema_agent, sql_generator_agent, sql_executor_agent = create_text_to_sql_system()
-    
-    # Test questions that should generate different SQL based on schema
-    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?"
-    ]
-    
-    print("\n🔍 Testing schema-aware SQL generation...")
-    
-    for i, question in enumerate(test_questions, 1):
-        print(f"\n--- Test {i}: {question} ---")
-        
-        try:
-            result = run_text_to_sql_query(
-                engine, schema_agent, sql_generator_agent, sql_executor_agent, question
-            )
-            
-            if result:
-                sql_query = result.get("sql_query", "")
-                print(f"✅ Generated SQL: {sql_query}")
-                
-                # Check if the SQL looks schema-aware
-                if "total_amount" in sql_query or "invoice_date" in sql_query or "vendor_name" in sql_query:
-                    print("🎯 SQL appears to use actual column names from schema!")
-                else:
-                    print("⚠️  SQL might not be using schema information")
-            else:
-                print("❌ SQL generation failed")
-                
-        except Exception as e:
-            print(f"❌ Error: {str(e)}")
-    
-    print(f"\n✨ Schema awareness test completed!")
-
-def main():
-    """Main function"""
-    try:
-        test_schema_awareness()
-    except KeyboardInterrupt:
-        print("\n\n⏹️  Test interrupted by user")
-    except Exception as e:
-        print(f"\n❌ Test failed with error: {str(e)}")
-
-if __name__ == "__main__":
-    main() 

memra-ops/tests/test_text_to_sql_demo.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python3
-"""
-Text-to-SQL Demo Script
-Automatically demonstrates the complete pipeline without user interaction
-"""
-
-import os
-import sys
-import json
-from pathlib import Path
-
-# Add the parent directory to the path so we can import memra
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from memra.tool_registry import ToolRegistry
-
-def test_text_to_sql_pipeline():
-    """Test the complete text-to-SQL pipeline using tool registry directly"""
-    print("🚀 Starting Text-to-SQL Demo")
-    print("=" * 60)
-    
-    # Initialize tool registry
-    registry = ToolRegistry()
-    
-    # MCP bridge configuration
-    mcp_config = {
-        "bridge_url": "http://localhost:8081",
-        "bridge_secret": "test-secret-for-development"
-    }
-    
-    # Test questions
-    test_questions = [
-        "Show me all invoices from Air Liquide",
-        "What is the total amount of all invoices?", 
-        "How many invoices do we have in the database?"
-    ]
-    
-    for i, question in enumerate(test_questions, 1):
-        print(f"\n{'='*60}")
-        print(f"🎯 Test {i}: {question}")
-        print(f"{'='*60}")
-        
-        try:
-            # Step 1: Extract schema (using Memra API)
-            print("🔍 Step 1: Extracting database schema...")
-            schema_result = registry.execute_tool(
-                tool_name="DatabaseQueryTool",
-                hosted_by="memra",
-                input_data={
-                    "task": "Extract the complete schema for the invoices table",
-                    "table_name": "invoices"
-                }
-            )
-            
-            if schema_result.get("success"):
-                print(f"✅ Schema extracted")
-                schema_data = schema_result.get("data", {})
-            else:
-                print(f"❌ Schema extraction failed: {schema_result.get('error')}")
-                # Use mock schema for demo
-                schema_data = {"tables": ["invoices"]}
-                print("📝 Using mock schema for demo")
-            
-            # Step 2: Generate SQL (using MCP bridge)
-            print(f"\n🤖 Step 2: Generating SQL for: '{question}'")
-            sql_result = registry.execute_tool(
-                tool_name="TextToSQLGenerator",
-                hosted_by="mcp",
-                input_data={
-                    "question": question,
-                    "schema_info": schema_data
-                },
-                config=mcp_config
-            )
-            
-            if sql_result.get("success"):
-                print(f"✅ SQL generated")
-                sql_data = sql_result.get("data", {})
-                generated_sql = sql_data.get("generated_sql", "")
-                print(f"📝 Generated SQL: {generated_sql}")
-                
-                # Check if it's real or mock
-                if sql_data.get("_mock"):
-                    print("ℹ️  Note: SQL generation is mocked (MCP bridge not fully connected)")
-                else:
-                    print("🎉 Real SQL generation!")
-            else:
-                print(f"❌ SQL generation failed: {sql_result.get('error')}")
-                continue
-            
-            # Step 3: Execute SQL (using MCP bridge)
-            print(f"\n⚡ Step 3: Executing SQL query...")
-            execution_result = registry.execute_tool(
-                tool_name="SQLExecutor",
-                hosted_by="mcp",
-                input_data={
-                    "sql_query": generated_sql
-                },
-                config=mcp_config
-            )
-            
-            if execution_result.get("success"):
-                print(f"✅ SQL executed")
-                query_results = execution_result.get("data", {})
-                
-                # Display results
-                results = query_results.get("results", [])
-                row_count = query_results.get("row_count", 0)
-                
-                print(f"\n📋 Query Results ({row_count} rows):")
-                if results:
-                    # Display first few results
-                    for j, row in enumerate(results[:3]):
-                        print(f"  Row {j+1}: {row}")
-                    
-                    if len(results) > 3:
-                        print(f"  ... and {len(results) - 3} more rows")
-                else:
-                    print("  No results found")
-                
-                # Check if results are real or mock
-                if query_results.get("_mock"):
-                    print("ℹ️  Note: Results are mocked (MCP bridge not fully connected)")
-                else:
-                    print("🎉 Real database results!")
-                    
-            else:
-                print(f"❌ SQL execution failed: {execution_result.get('error')}")
-            
-            print(f"\n✨ Test {i} completed!")
-            
-        except Exception as e:
-            print(f"\n❌ Test {i} failed with error: {str(e)}")
-    
-    print(f"\n{'='*60}")
-    print("🏁 Demo completed!")
-    print(f"{'='*60}")
-
-if __name__ == "__main__":
-    test_text_to_sql_pipeline()