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

memra-workflows/text_to_sql/complete_text_to_sql_system.py

@@ -1,266 +0,0 @@
-#!/usr/bin/env python3
-"""
-Complete Text-to-SQL System
-Demonstrates the full pipeline: English Question → Schema → SQL Generation → Execution → Real Results
-"""
-
-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 import ExecutionEngine, Agent, Tool
-
-def create_text_to_sql_system():
-    """Create a complete text-to-SQL system with real database integration"""
-    
-    # Initialize execution engine
-    engine = ExecutionEngine()
-    
-    # Schema Extraction Agent
-    schema_agent = Agent(
-        role="Database Schema Analyst",
-        job="Extract and analyze database schemas",
-        output_key="schema_data",
-        tools=[
-            Tool(
-                name="DatabaseQueryTool",
-                hosted_by="memra",
-                description="Query database schemas and structure"
-            )
-        ]
-    )
-    
-    # SQL Generation Agent  
-    sql_generator_agent = Agent(
-        role="SQL Generator",
-        job="Convert natural language to SQL queries",
-        output_key="generated_sql",
-        tools=[
-            Tool(
-                name="TextToSQLGenerator",
-                hosted_by="mcp",
-                description="Generate SQL from natural language questions",
-                config={
-                    "bridge_url": "http://localhost:8081",
-                    "bridge_secret": "test-secret-for-development"
-                }
-            )
-        ]
-    )
-    
-    # SQL Execution Agent
-    sql_executor_agent = Agent(
-        role="SQL Executor",
-        job="Execute SQL queries and return results",
-        output_key="query_results",
-        tools=[
-            Tool(
-                name="SQLExecutor", 
-                hosted_by="mcp",
-                description="Execute SQL queries against PostgreSQL database",
-                config={
-                    "bridge_url": "http://localhost:8081",
-                    "bridge_secret": "test-secret-for-development"
-                }
-            )
-        ]
-    )
-    
-    return engine, schema_agent, sql_generator_agent, sql_executor_agent
-
-def extract_database_schema(engine, schema_agent):
-    """Extract the database schema for context"""
-    print("🔍 Extracting database schema...")
-    
-    schema_task = {
-        "task": "Extract the complete schema for the invoices table including column names, types, and sample data",
-        "table_name": "invoices",
-        "include_sample_data": True
-    }
-    
-    result = engine.execute_task(schema_agent, schema_task)
-    
-    if result.get("success"):
-        print(f"✅ Schema extracted successfully ({result.get('execution_time', 0):.1f}s)")
-        schema_data = result.get("result", {})
-        
-        # 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']})")
-        
-        return schema_data
-    else:
-        print(f"❌ Schema extraction failed: {result.get('error', 'Unknown error')}")
-        return {}
-
-def generate_sql_from_question(engine, sql_generator_agent, question, schema_info):
-    """Generate SQL from natural language question"""
-    print(f"\n🤖 Generating SQL for: '{question}'")
-    
-    sql_generation_task = {
-        "question": question,
-        "schema_info": schema_info,
-        "context": "Generate SQL query for invoice database analysis"
-    }
-    
-    result = engine.execute_task(sql_generator_agent, sql_generation_task)
-    
-    if result.get("success"):
-        print(f"✅ SQL generated successfully ({result.get('execution_time', 0):.1f}s)")
-        sql_data = result.get("result", {})
-        
-        generated_sql = sql_data.get("generated_sql", "")
-        print(f"\n📝 Generated SQL:")
-        print(f"   {generated_sql}")
-        
-        return generated_sql
-    else:
-        print(f"❌ SQL generation failed: {result.get('error', 'Unknown error')}")
-        return None
-
-def execute_sql_query(engine, sql_executor_agent, sql_query):
-    """Execute the generated SQL query"""
-    print(f"\n⚡ Executing SQL query...")
-    
-    execution_task = {
-        "sql_query": sql_query,
-        "timeout": 30
-    }
-    
-    result = engine.execute_task(sql_executor_agent, execution_task)
-    
-    if result.get("success"):
-        print(f"✅ SQL executed successfully ({result.get('execution_time', 0):.1f}s)")
-        query_results = result.get("result", {})
-        
-        # 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 i, row in enumerate(results[:5]):
-                print(f"  Row {i+1}: {row}")
-            
-            if len(results) > 5:
-                print(f"  ... and {len(results) - 5} more rows")
-        else:
-            print("  No results found")
-        
-        return query_results
-    else:
-        print(f"❌ SQL execution failed: {result.get('error', 'Unknown error')}")
-        return {}
-
-def run_text_to_sql_query(engine, schema_agent, sql_generator_agent, sql_executor_agent, question):
-    """Run the complete text-to-SQL pipeline"""
-    print(f"\n{'='*60}")
-    print(f"🎯 Processing Question: {question}")
-    print(f"{'='*60}")
-    
-    # Step 1: Extract schema (cached after first run)
-    if not hasattr(run_text_to_sql_query, 'cached_schema'):
-        run_text_to_sql_query.cached_schema = extract_database_schema(engine, schema_agent)
-    
-    schema_info = run_text_to_sql_query.cached_schema
-    
-    # Step 2: Generate SQL
-    sql_query = generate_sql_from_question(engine, sql_generator_agent, question, schema_info)
-    
-    if not sql_query:
-        return None
-    
-    # Step 3: Execute SQL
-    results = execute_sql_query(engine, sql_executor_agent, sql_query)
-    
-    return {
-        "question": question,
-        "sql_query": sql_query,
-        "results": results
-    }
-
-def main():
-    """Main function to demonstrate the complete text-to-SQL system"""
-    print("🚀 Starting Complete Text-to-SQL System")
-    print("=" * 60)
-    
-    # Create the system
-    engine, schema_agent, sql_generator_agent, sql_executor_agent = create_text_to_sql_system()
-    
-    # Example questions to test
-    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?",
-        "Show me the most recent 5 invoices",
-        "What is the average invoice amount?",
-    ]
-    
-    print("📝 Available test questions:")
-    for i, question in enumerate(test_questions, 1):
-        print(f"  {i}. {question}")
-    
-    print("\n" + "="*60)
-    
-    # Interactive mode
-    while True:
-        print("\n🤔 What would you like to know about the invoices?")
-        print("   (Enter a question, number 1-5 for examples, or 'quit' to exit)")
-        
-        user_input = input("\n❓ Your question: ").strip()
-        
-        if user_input.lower() in ['quit', 'exit', 'q']:
-            print("\n👋 Goodbye!")
-            break
-        
-        # Check if it's a number for example questions
-        if user_input.isdigit():
-            question_num = int(user_input)
-            if 1 <= question_num <= len(test_questions):
-                question = test_questions[question_num - 1]
-            else:
-                print(f"❌ Please enter a number between 1 and {len(test_questions)}")
-                continue
-        else:
-            question = user_input
-        
-        if not question:
-            print("❌ Please enter a question")
-            continue
-        
-        # Run the complete pipeline
-        try:
-            result = run_text_to_sql_query(
-                engine, schema_agent, sql_generator_agent, sql_executor_agent, question
-            )
-            
-            if result:
-                print(f"\n✨ Query completed successfully!")
-                
-                # Check if results are real or mock
-                results_data = result.get("results", {})
-                if results_data.get("_mock"):
-                    print("ℹ️  Note: Results are mocked (MCP bridge not fully connected)")
-                else:
-                    print("🎉 Real database results!")
-            else:
-                print("❌ Query failed")
-                
-        except KeyboardInterrupt:
-            print("\n\n⏹️  Query interrupted by user")
-        except Exception as e:
-            print(f"\n❌ Error: {str(e)}")
-
-if __name__ == "__main__":
-    main() 

memra-workflows/text_to_sql/file_discovery_demo.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-"""
-File Discovery and Management Demo
-Simple demonstration of intelligent file discovery tools
-"""
-
-import os
-import sys
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from memra import Agent, Department
-from memra.execution import ExecutionEngine
-
-# Set up environment
-os.environ['MEMRA_API_KEY'] = 'memra-prod-2024-001'
-
-def create_file_discovery_department():
-    """Create a simple department for file discovery"""
-    file_manager_agent = Agent(
-        role="File Manager",
-        job="Discover and manage files in directories",
-        sops=[
-            "Scan specified directory for files matching pattern",
-            "List all discovered files with metadata",
-            "Copy files from external locations to standard directories",
-            "Provide file selection interface for multiple files"
-        ],
-        systems=["FileSystem"],
-        tools=[
-            {"name": "FileDiscovery", "hosted_by": "mcp"}
-        ],
-        input_keys=["directory", "pattern"],
-        output_key="file_operations"
-    )
-    
-    return Department(
-        name="File Discovery",
-        mission="Discover files in directories",
-        agents=[file_manager_agent],
-        workflow_order=["File Manager"],
-        context={
-            "mcp_bridge_url": "http://localhost:8081",
-            "mcp_bridge_secret": "test-secret-for-development"
-        }
-    )
-
-def create_file_copy_department():
-    """Create a simple department for file copying"""
-    file_copy_agent = Agent(
-        role="File Copier",
-        job="Copy files from external locations to standard directories",
-        sops=[
-            "Accept source file path and destination directory",
-            "Copy file to destination with proper naming",
-            "Verify copy operation success",
-            "Return copy confirmation with metadata"
-        ],
-        systems=["FileSystem"],
-        tools=[
-            {"name": "FileCopy", "hosted_by": "mcp"}
-        ],
-        input_keys=["source_path", "destination_dir"],
-        output_key="file_operations"
-    )
-    
-    return Department(
-        name="File Copy",
-        mission="Copy files to standard directories",
-        agents=[file_copy_agent],
-        workflow_order=["File Copier"],
-        context={
-            "mcp_bridge_url": "http://localhost:8081",
-            "mcp_bridge_secret": "test-secret-for-development"
-        }
-    )
-
-def main():
-    print("📁 File Discovery and Management Demo")
-    print("=" * 50)
-    
-    engine = ExecutionEngine()
-    
-    # Demo 1: Discover files in invoices directory
-    print("\n🔍 Demo 1: Discover files in invoices/ directory")
-    
-    discovery_dept = create_file_discovery_department()
-    discovery_input = {
-        "directory": "invoices",
-        "pattern": "*.pdf"
-    }
-    
-    result = engine.execute_department(discovery_dept, discovery_input)
-    
-    if result.success:
-        print("✅ File discovery completed!")
-        file_data = result.data.get('file_operations', {})
-        
-        if 'files' in file_data:
-            print(f"\n📄 Found {file_data['files_found']} files:")
-            for file_info in file_data['files']:
-                print(f"  • {file_info['filename']} ({file_info['size']}) - {file_info['modified']}")
-        else:
-            print(f"📊 Scanned: {file_data.get('directory', 'unknown')} directory")
-            print(f"🔍 Pattern: {file_data.get('pattern', 'unknown')}")
-            print(f"📁 Files found: {file_data.get('files_found', 0)}")
-    else:
-        print(f"❌ Discovery failed: {result.error}")
-    
-    print("\n" + "="*50)
-    
-    # Demo 2: Copy external file
-    print("\n📋 Demo 2: Copy external file to invoices/ directory")
-    
-    copy_dept = create_file_copy_department()
-    copy_input = {
-        "source_path": "/Users/tarpus/Downloads/new_invoice.pdf",
-        "destination_dir": "invoices"
-    }
-    
-    result = engine.execute_department(copy_dept, copy_input)
-    
-    if result.success:
-        print("✅ File copy completed!")
-        copy_data = result.data.get('file_operations', {})
-        
-        print(f"\n📁 Copy Details:")
-        print(f"  Source: {copy_data.get('source_path', 'unknown')}")
-        print(f"  Destination: {copy_data.get('destination_path', 'unknown')}")
-        print(f"  Size: {copy_data.get('file_size', 'unknown')}")
-        print(f"  Status: {copy_data.get('message', 'unknown')}")
-    else:
-        print(f"❌ Copy failed: {result.error}")
-    
-    print("\n" + "="*50)
-    
-    # Demo 3: Discover files in different directory
-    print("\n🗂 Demo 3: Discover files in documents/ directory")
-    
-    docs_input = {
-        "directory": "documents",
-        "pattern": "*.*"
-    }
-    
-    result = engine.execute_department(discovery_dept, docs_input)
-    
-    if result.success:
-        print("✅ Document discovery completed!")
-        doc_data = result.data.get('file_operations', {})
-        print(f"📊 Scanned: {doc_data.get('directory', 'unknown')} directory")
-        print(f"🔍 Pattern: {doc_data.get('pattern', 'unknown')}")
-        print(f"📁 Files found: {doc_data.get('files_found', 0)}")
-    else:
-        print(f"❌ Document discovery failed: {result.error}")
-
-if __name__ == "__main__":
-    main()