memra 0.2.3__py3-none-any.whl → 0.2.5__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.3.dist-info/METADATA

@@ -1,101 +0,0 @@
-Metadata-Version: 2.4
-Name: memra
-Version: 0.2.3
-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
-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"
-Dynamic: author
-Dynamic: home-page
-Dynamic: requires-python
-
-# Memra SDK
-
-The core Memra framework for building AI-powered business workflows.
-
-## Installation
-
-```bash
-pip install memra
-```
-
-## Quick Start
-
-```python
-from memra import Agent, Department, LLM, ExecutionEngine
-
-# Define an agent
-agent = Agent(
-    role="Data Analyst",
-    job="Analyze customer data",
-    llm=LLM(model="llama-3.2-11b-vision-preview"),
-    sops=["Load data", "Perform analysis", "Generate report"],
-    output_key="analysis_result"
-)
-
-# Create a department
-department = Department(
-    name="Analytics",
-    mission="Provide data insights",
-    agents=[agent],
-    workflow_order=["Data Analyst"]
-)
-
-# Execute the workflow
-engine = ExecutionEngine()
-result = engine.execute_department(department, {"data": "customer_data.csv"})
-```
-
-## Core Components
-
-### Agent
-An AI worker that performs specific tasks using LLMs and tools.
-
-### Department
-A team of agents working together to accomplish a mission.
-
-### ExecutionEngine
-Orchestrates the execution of departments and their workflows.
-
-### LLM
-Configuration for language models used by agents.
-
-## Examples
-
-See the `examples/` directory for basic usage examples:
-- `simple_text_to_sql.py` - Basic text-to-SQL conversion
-- `ask_questions.py` - Simple question answering
-
-## Documentation
-
-For detailed documentation, visit [docs.memra.co](https://docs.memra.co)
-
-## License
-
-MIT License - see LICENSE file for details. 

memra-0.2.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-memra/__init__.py,sha256=zVO29fnEDclBI9x9SFVzF9uJYAKhPDTNrMFMWuw6JC8,787
-memra/discovery.py,sha256=yJIQnrDQu1nyzKykCIuzG_5SW5dIXHCEBLLKRWacIoY,480
-memra/discovery_client.py,sha256=AbnKn6qhyrf7vmOvknEeDzH4tiGHsqPHtDaein_qaW0,1271
-memra/execution.py,sha256=P7tAur0SEMtX6uLlfxTfCZBgMLIRj6Wl3dsv2EA9fHc,23443
-memra/models.py,sha256=sXMPRnMB_mUVtJdBFyd0ElCf_uh1yqx7iLssIYNm0vI,3333
-memra/tool_registry.py,sha256=P2TafpiqV19yzi0jVrQQrXFGBpQkbmePbRfEW_ai24M,14700
-memra/tool_registry_client.py,sha256=uzMQ4COvRams9vuPLcqcdljUpDlAYU_tyFxrRhrA0Lc,4009
-memra-0.2.3.dist-info/METADATA,sha256=gr4yyJc9wX49JFvxLdbQCP7HFdoEC_NqSH06uxvnq08,2737
-memra-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-memra-0.2.3.dist-info/entry_points.txt,sha256=LBVjwWoxWJRzNLgeByPn6xUvWFIRnqnemvAZgIoSt08,41
-memra-0.2.3.dist-info/top_level.txt,sha256=pXWcTRS1zctdiSUivW4iyKpJ4tcfIu-1BW_fpbal3OY,6
-memra-0.2.3.dist-info/RECORD,,

memra-0.2.3.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-memra = memra.cli:main

memra-0.2.3.dist-info/top_level.txt

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