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

memra-workflows/text_to_sql/complete_text_to_sql_system.py

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

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

memra-0.2.2.dist-info/METADATA

@@ -1,148 +0,0 @@
-Metadata-Version: 2.1
-Name: memra
-Version: 0.2.2
-Summary: Declarative framework for enterprise workflows with MCP integration - Client SDK
-Home-page: https://github.com/memra/memra-sdk
-Author: Memra
-Author-email: Memra <support@memra.com>
-License: MIT
-Project-URL: Homepage, https://memra.co
-Project-URL: Repository, https://github.com/memra-platform/memra-sdk
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-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
-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"
-Provides-Extra: mcp
-Requires-Dist: psycopg2-binary>=2.9.0; extra == "mcp"
-
-# Memra SDK
-
-A declarative orchestration framework for AI-powered business workflows. Think of it as "Kubernetes for business logic" where agents are the pods and departments are the deployments.
-
-## 🚀 Team Setup
-
-**New team member?** See the complete setup guide: **[TEAM_SETUP.md](TEAM_SETUP.md)**
-
-This includes:
-- Database setup (PostgreSQL + Docker)
-- Local development environment
-- Testing instructions
-- Troubleshooting guide
-
-## Quick Start
-
-```python
-from memra.sdk.models import Agent, Department, Tool
-
-# Define your agents
-data_extractor = Agent(
-    role="Data Extraction Specialist",
-    job="Extract and validate data",
-    tools=[Tool(name="DataExtractor", hosted_by="memra")],
-    input_keys=["input_data"],
-    output_key="extracted_data"
-)
-
-# Create a department
-dept = Department(
-    name="Data Processing",
-    mission="Process and validate data",
-    agents=[data_extractor]
-)
-
-# Run the workflow
-result = dept.run({"input_data": {...}})
-```
-
-## Installation
-
-```bash
-pip install memra
-```
-
-## API Access
-
-Memra requires an API key to execute workflows on the hosted infrastructure.
-
-### Get Your API Key
-Contact [info@memra.co](mailto:info@memra.co) for API access.
-
-### Set Your API Key
-```bash
-# Set environment variable
-export MEMRA_API_KEY="your-api-key-here"
-
-# Or add to your shell profile for persistence
-echo 'export MEMRA_API_KEY="your-api-key-here"' >> ~/.zshrc
-```
-
-### Test Your Setup
-```bash
-python examples/accounts_payable_client.py
-```
-
-## Architecture
-
-The Memra platform consists of three main components:
-
-- **Memra SDK** (this repository): Client library for building and executing workflows
-- **Memra Server**: Hosted infrastructure for heavy AI processing tools
-- **MCP Bridge**: Local execution environment for database operations
-
-Tools are automatically routed between server and local execution based on their `hosted_by` configuration.
-
-## Documentation
-
-Documentation is coming soon. For now, see the examples below and in the `examples/` directory.
-
-## Example: Propane Delivery Workflow
-
-See the `examples/propane_delivery.py` file for a complete example of how to use Memra to orchestrate a propane delivery workflow.
-
-## Contributing
-
-We welcome contributions! Please see our [contributing guide](CONTRIBUTING.md) for details.
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## Repository Structure
-
-```
-├── examples/                       # Example workflows and use cases
-│   ├── accounts_payable_client.py  # API-based accounts payable workflow
-│   ├── accounts_payable_mcp.py     # MCP-enabled accounts payable workflow
-│   ├── invoice_processing.py       # Simple invoice processing example
-│   └── propane_delivery.py         # Propane delivery domain example
-├── memra/                          # Core SDK package
-│   ├── __init__.py                 # Package initialization
-│   ├── tool_registry.py            # Tool discovery and routing
-│   └── sdk/                        # SDK components
-│       ├── __init__.py
-│       ├── client.py               # API client
-│       ├── execution_engine.py     # Workflow execution
-│       └── models.py               # Core data models
-├── docs/                           # Documentation
-├── tests/                          # Test suite
-├── local/dependencies/             # Local development setup
-└── scripts/                        # Utility scripts
-```

memra-0.2.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-memra/__init__.py,sha256=5WPh9vku8_ZV4T6WayAqArKAj1RDkbL47SsnA9GWD7A,662
-memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
-memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
-memra/execution.py,sha256=bg822ED6yYN7APjPac1LRhv48gtxV4DUPvzpyLyBa2I,21443
-memra/models.py,sha256=sXMPRnMB_mUVtJdBFyd0ElCf_uh1yqx7iLssIYNm0vI,3333
-memra/tool_registry.py,sha256=N7kpYQxgJcSMDDCX-_6og1-of3QKEaoz6H16ptCCg48,7784
-memra/tool_registry_client.py,sha256=uzMQ4COvRams9vuPLcqcdljUpDlAYU_tyFxrRhrA0Lc,4009
-memra-0.2.2.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-memra-0.2.2.dist-info/METADATA,sha256=jrZ9AwcGtPK-pc9TGGGoi1oJzXxcGx7LUsbsd6NxcxA,4856
-memra-0.2.2.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-memra-0.2.2.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
-memra-0.2.2.dist-info/top_level.txt,sha256=pXWcTRS1zctdiSUivW4iyKpJ4tcfIu-1BW_fpbal3OY,6
-memra-0.2.2.dist-info/RECORD,,

memra-0.2.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-memra