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

memra-sdk/examples/ask_questions.py

@@ -1,123 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple interactive script to ask questions about invoices
-"""
-
-import requests
-import json
-
-def ask_question(question):
-    """Ask a question and get SQL + results"""
-    bridge_url = "http://localhost:8081"
-    bridge_secret = "test-secret-for-development"
-    
-    # No hard-coded schema - let the server fetch it dynamically
-    schema_info = {}
-    
-    headers = {
-        "Content-Type": "application/json",
-        "X-Bridge-Secret": bridge_secret
-    }
-    
-    print(f"\n🤖 Processing: {question}")
-    print("-" * 50)
-    
-    # Step 1: Generate SQL
-    sql_request = {
-        "tool_name": "TextToSQLGenerator",
-        "input_data": {
-            "question": question,
-            "schema_info": schema_info
-        }
-    }
-    
-    try:
-        response = requests.post(f"{bridge_url}/execute_tool", json=sql_request, headers=headers, timeout=60)
-        
-        if response.status_code != 200:
-            print(f"❌ SQL generation failed: HTTP {response.status_code}")
-            return
-        
-        result = response.json()
-        if not result.get("success"):
-            print(f"❌ SQL generation failed: {result.get('error')}")
-            return
-        
-        data = result.get("data", {})
-        sql_query = data.get("generated_sql", "")
-        method = data.get("method", "unknown")
-        
-        # Check if SQL is incomplete
-        if not sql_query or sql_query.strip() == "SELECT" or len(sql_query.strip()) < 10:
-            print(f"❌ Generated incomplete SQL: '{sql_query}'")
-            print("💡 Try rephrasing your question more simply")
-            return
-        
-        print(f"📝 Generated SQL: {sql_query}")
-        print(f"💡 Method: {method}")
-        
-        # Step 2: Execute SQL
-        exec_request = {
-            "tool_name": "SQLExecutor",
-            "input_data": {
-                "sql_query": sql_query
-            }
-        }
-        
-        response = requests.post(f"{bridge_url}/execute_tool", json=exec_request, headers=headers, timeout=60)
-        
-        if response.status_code != 200:
-            print(f"❌ SQL execution failed: HTTP {response.status_code}")
-            return
-        
-        result = response.json()
-        if not result.get("success"):
-            print(f"❌ SQL execution failed: {result.get('error')}")
-            return
-        
-        exec_data = result.get("data", {})
-        results = exec_data.get("results", [])
-        row_count = exec_data.get("row_count", 0)
-        
-        print(f"\n📊 Results ({row_count} rows):")
-        if results:
-            # Show first 5 results
-            for i, row in enumerate(results[:5], 1):
-                print(f"  {i}. {row}")
-            
-            if len(results) > 5:
-                print(f"  ... and {len(results) - 5} more rows")
-        else:
-            print("  No results found")
-            
-    except Exception as e:
-        print(f"❌ Error: {str(e)}")
-
-def main():
-    """Interactive question asking"""
-    print("🎯 Invoice Question Assistant")
-    print("=" * 50)
-    print("Ask questions about your invoices in natural language!")
-    print("Examples:")
-    print("  - Show me all invoices from Air Liquide")
-    print("  - Find invoices with amounts greater than 1000")
-    print("  - What is the total amount of all invoices?")
-    print("  - How many invoices do we have?")
-    print("\nType 'quit' to exit")
-    
-    while True:
-        print("\n" + "="*50)
-        question = input("❓ Your question: ").strip()
-        
-        if question.lower() in ['quit', 'exit', 'q']:
-            print("👋 Goodbye!")
-            break
-        
-        if not question:
-            print("Please enter a question")
-            continue
-        
-        ask_question(question)
-
-if __name__ == "__main__":
-    main() 

memra-sdk/examples/invoice_processing.py

@@ -1,116 +0,0 @@
-from memra import Agent, Department, LLM
-
-# Define LLMs that agents can use
-default_llm = LLM(model="gpt-4", temperature=0.1)
-parsing_llm = LLM(model="claude-3-opus", temperature=0)  # More accurate for structured extraction
-manager_llm = LLM(model="gpt-4-turbo", temperature=0.3)  # Balanced for decision-making
-
-# Define agents with specific LLMs
-etl_agent = Agent(
-    role="Data Engineer",
-    job="Extract invoice schema from Postgres database",
-    llm=default_llm,  # Standard LLM for SQL generation
-    sops=[
-        "Connect to PostgresDB using credentials",
-        "Query information_schema for invoices table",
-        "Extract column names, types, and constraints",
-        "Return schema as structured JSON"
-    ],
-    systems=["PostgresDB"],
-    tools=[
-        {"name": "DatabaseQueryTool", "hosted_by": "memra"}
-    ],
-    output_key="invoice_schema"
-)
-
-parser_agent = Agent(
-    role="Invoice Parser",
-    job="Extract structured data from invoice PDF using schema",
-    llm=parsing_llm,  # High-accuracy LLM for document parsing
-    sops=[
-        "Load invoice PDF file",
-        "Convert to high-contrast images if needed",
-        "Run OCR to extract text",
-        "Use schema to identify and extract fields",
-        "Validate extracted data against schema types",
-        "Return structured invoice data"
-    ],
-    systems=["InvoiceStore"],
-    tools=[
-        {"name": "PDFProcessor", "hosted_by": "memra"},
-        {"name": "OCRTool", "hosted_by": "memra"},
-        {"name": "InvoiceExtractionWorkflow", "hosted_by": "memra"}
-    ],
-    input_keys=["file", "invoice_schema"],
-    output_key="invoice_data"
-)
-
-writer_agent = Agent(
-    role="Data Entry Specialist",
-    job="Write validated invoice data to Postgres database",
-    llm=default_llm,
-    sops=[
-        "Validate invoice data completeness",
-        "Map fields to database columns using schema",
-        "Connect to PostgresDB",
-        "Insert record into invoices table",
-        "Return confirmation with record ID"
-    ],
-    systems=["PostgresDB"],
-    tools=[
-        {"name": "DataValidator", "hosted_by": "memra"},
-        {"name": "PostgresInsert", "hosted_by": "mcp"}
-    ],
-    input_keys=["invoice_data", "invoice_schema"],
-    output_key="write_confirmation"
-)
-
-# Manager with its own LLM
-manager_agent = Agent(
-    role="Accounts Payable Manager",
-    job="Coordinate invoice processing pipeline and handle exceptions",
-    llm=manager_llm,  # Manager gets a more flexible LLM
-    sops=[
-        "Check if schema extraction succeeded",
-        "If schema missing, delegate to Schema Loader",
-        "Validate parsed invoice has required fields",
-        "Ensure invoice total matches line items before DB write",
-        "Handle and log any errors with appropriate escalation"
-    ],
-    allow_delegation=True,
-    fallback_agents={
-        "Data Engineer": "Schema Loader"
-    },
-    output_key="workflow_status"
-)
-
-# Create the Accounts Payable Department
-ap_department = Department(
-    name="Accounts Payable",
-    mission="Process invoices accurately into financial system per company data standards",
-    agents=[etl_agent, parser_agent, writer_agent],
-    manager_agent=manager_agent,
-    default_llm=default_llm,  # Fallback for any agent without explicit LLM
-    workflow_order=["Data Engineer", "Invoice Parser", "Data Entry Specialist"]
-)
-
-# Example usage
-if __name__ == "__main__":
-    from memra.execution import ExecutionEngine
-    
-    # This is how a developer would use the department
-    engine = ExecutionEngine()
-    input_data = {
-        "file": "path/to/invoice.pdf",
-        "connection": "postgres://ap_user:password@localhost:5432/finance"
-    }
-    
-    result = engine.execute_department(ap_department, input_data)
-    
-    if result.success:
-        print("✅ Invoice processing completed!")
-        print(f"Result: {result.data}")
-    else:
-        print(f"❌ Processing failed: {result.error}")
-    
-    print(f"Workflow result: {result}") 

memra-sdk/examples/propane_delivery.py

@@ -1,87 +0,0 @@
-from memra.sdk.models import Agent, Department, Tool
-
-# Define the tools that our agents will use
-data_extraction_tool = Tool(
-    name="PropaneDataExtractor",
-    description="Extracts propane-related data from various sources",
-    hosted_by="memra"
-)
-
-planning_tool = Tool(
-    name="PropaneDeliveryPlanner",
-    description="Plans optimal propane delivery routes and schedules",
-    hosted_by="memra"
-)
-
-execution_tool = Tool(
-    name="PropaneDeliveryExecutor",
-    description="Executes and tracks propane deliveries",
-    hosted_by="memra"
-)
-
-# Define our agents
-data_extractor = Agent(
-    role="Data Extraction Specialist",
-    job="Extract and validate propane delivery data",
-    tools=[data_extraction_tool],
-    systems=["CustomerDatabase", "PropaneLevelsAPI"],
-    input_keys=["customer_ids", "date_range"],
-    output_key="extracted_data"
-)
-
-delivery_planner = Agent(
-    role="Delivery Route Planner",
-    job="Plan optimal delivery routes and schedules",
-    tools=[planning_tool],
-    systems=["RouteOptimizationEngine"],
-    input_keys=["extracted_data"],
-    output_key="delivery_plan"
-)
-
-delivery_executor = Agent(
-    role="Delivery Coordinator",
-    job="Execute and monitor propane deliveries",
-    tools=[execution_tool],
-    systems=["DeliveryTrackingSystem"],
-    input_keys=["delivery_plan"],
-    output_key="delivery_status"
-)
-
-# Define the manager agent that oversees the workflow
-manager = Agent(
-    role="Propane Operations Manager",
-    job="Oversee and coordinate the propane delivery workflow",
-    llm={"model": "claude-3-opus"},
-    sops=[
-        "Validate data quality",
-        "Handle delivery exceptions",
-        "Optimize resource allocation"
-    ],
-    input_keys=["extracted_data", "delivery_plan", "delivery_status"],
-    output_key="workflow_status"
-)
-
-# Create the Propane Delivery Department
-propane_department = Department(
-    name="Propane Delivery Operations",
-    mission="Efficiently manage and execute propane deliveries",
-    agents=[data_extractor, delivery_planner, delivery_executor],
-    manager_agent=manager,
-    workflow_order=[
-        "Data Extraction Specialist",
-        "Delivery Route Planner",
-        "Delivery Coordinator"
-    ]
-)
-
-# Example usage
-if __name__ == "__main__":
-    # This is how a developer would use the department
-    result = propane_department.run({
-        "customer_ids": ["CUST001", "CUST002"],
-        "date_range": {
-            "start": "2024-03-20",
-            "end": "2024-03-27"
-        }
-    })
-    print(f"Workflow result: {result}") 

memra-sdk/examples/simple_text_to_sql.py

@@ -1,158 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple Text-to-SQL Interface
-Direct connection to MCP bridge for asking questions about invoices
-"""
-
-import requests
-import json
-
-def ask_question(question):
-    """Ask a question and get SQL + results"""
-    bridge_url = "http://localhost:8081"
-    bridge_secret = "test-secret-for-development"
-    
-    # Simulated schema info (in real system this would come from schema extraction)
-    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(f"\n🤖 Processing: {question}")
-    print("-" * 50)
-    
-    # Step 1: Generate SQL
-    sql_request = {
-        "tool_name": "TextToSQLGenerator",
-        "input_data": {
-            "question": question,
-            "schema_info": schema_info
-        }
-    }
-    
-    try:
-        response = requests.post(f"{bridge_url}/execute_tool", json=sql_request, headers=headers, timeout=10)
-        
-        if response.status_code != 200:
-            print(f"❌ SQL generation failed: HTTP {response.status_code}")
-            return
-        
-        result = response.json()
-        if not result.get("success"):
-            print(f"❌ SQL generation failed: {result.get('error')}")
-            return
-        
-        data = result.get("data", {})
-        sql_query = data.get("generated_sql", "")
-        explanation = data.get("explanation", "")
-        
-        print(f"📝 Generated SQL: {sql_query}")
-        print(f"💡 Explanation: {explanation}")
-        
-        # Step 2: Execute SQL
-        exec_request = {
-            "tool_name": "SQLExecutor",
-            "input_data": {
-                "sql_query": sql_query
-            }
-        }
-        
-        response = requests.post(f"{bridge_url}/execute_tool", json=exec_request, headers=headers, timeout=10)
-        
-        if response.status_code != 200:
-            print(f"❌ SQL execution failed: HTTP {response.status_code}")
-            return
-        
-        result = response.json()
-        if not result.get("success"):
-            print(f"❌ SQL execution failed: {result.get('error')}")
-            return
-        
-        exec_data = result.get("data", {})
-        results = exec_data.get("results", [])
-        row_count = exec_data.get("row_count", 0)
-        
-        print(f"\n📊 Results ({row_count} rows):")
-        if results:
-            # Show first 10 results
-            for i, row in enumerate(results[:10], 1):
-                print(f"  {i}. {row}")
-            
-            if len(results) > 10:
-                print(f"  ... and {len(results) - 10} more rows")
-        else:
-            print("  No results found")
-            
-    except Exception as e:
-        print(f"❌ Error: {str(e)}")
-
-def main():
-    """Interactive text-to-SQL interface"""
-    print("🚀 Simple Text-to-SQL Interface")
-    print("=" * 50)
-    print("Ask questions about your invoice database!")
-    print("Examples:")
-    print("  • Show me all invoices from Air Liquide")
-    print("  • What is the total amount of all invoices?")
-    print("  • How many invoices do we have?")
-    print("  • Show me the 5 most recent invoices")
-    print("  • What is the average invoice amount?")
-    print("\nType 'quit' to exit")
-    print("=" * 50)
-    
-    # Check if MCP bridge is running
-    try:
-        response = requests.get("http://localhost:8081/health", timeout=5)
-        if response.status_code == 200:
-            print("✅ MCP Bridge server is running")
-        else:
-            print("❌ MCP Bridge server is not responding")
-            return
-    except Exception as e:
-        print(f"❌ Cannot connect to MCP Bridge server: {str(e)}")
-        print("💡 Make sure to start the MCP bridge server first:")
-        print("   source /Users/tarpus/miniconda3/bin/activate memra && \\")
-        print("   export MCP_POSTGRES_URL=\"postgresql://tarpus@localhost:5432/memra_invoice_db\" && \\")
-        print("   export MCP_BRIDGE_SECRET=\"test-secret-for-development\" && \\")
-        print("   python3 mcp_bridge_server.py")
-        return
-    
-    while True:
-        try:
-            question = input("\n❓ Your question: ").strip()
-            
-            if question.lower() in ['quit', 'exit', 'q']:
-                print("\n👋 Goodbye!")
-                break
-            
-            if not question:
-                print("Please enter a question")
-                continue
-            
-            ask_question(question)
-            
-        except KeyboardInterrupt:
-            print("\n\n👋 Goodbye!")
-            break
-        except Exception as e:
-            print(f"\n❌ Error: {str(e)}")
-
-if __name__ == "__main__":
-    main() 

memra-sdk/memra/__init__.py

@@ -1,31 +0,0 @@
-"""
-Memra SDK - Declarative AI Workflows
-
-A framework for building AI-powered business workflows using a declarative approach.
-Think of it as "Kubernetes for business logic" where agents are the pods and 
-departments are the deployments.
-"""
-
-__version__ = "0.2.4"
-
-# Core imports
-from .models import Agent, Department, Tool, LLM
-from .execution import ExecutionEngine
-from .discovery_client import check_api_health, get_api_status
-
-# Make key classes available at package level
-__all__ = [
-    "Agent",
-    "Department", 
-    "Tool",
-    "LLM",
-    "ExecutionEngine",
-    "check_api_health",
-    "get_api_status",
-    "__version__"
-]
-
-# Optional: Add version check for compatibility
-import sys
-if sys.version_info < (3, 8):
-    raise RuntimeError("Memra requires Python 3.8 or higher") 

memra-sdk/memra/discovery.py

@@ -1,15 +0,0 @@
-from typing import List, Dict, Any, Optional
-from .tool_registry import ToolRegistry
-
-def discover_tools(hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
-    """
-    Discover available tools in the Memra platform.
-    
-    Args:
-        hosted_by: Filter tools by host ("memra" or "mcp"). If None, returns all tools.
-    
-    Returns:
-        List of available tools with their metadata
-    """
-    registry = ToolRegistry()
-    return registry.discover_tools(hosted_by) 

memra-sdk/memra/discovery_client.py

@@ -1,49 +0,0 @@
-"""
-Client-side tool discovery for Memra SDK
-Queries the Memra API to discover available tools
-"""
-
-from typing import List, Dict, Any, Optional
-from .tool_registry_client import ToolRegistryClient
-
-def discover_tools(hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
-    """
-    Discover available tools from the Memra API
-    
-    Args:
-        hosted_by: Filter tools by hosting provider ("memra" or "mcp")
-        
-    Returns:
-        List of available tools with their descriptions
-    """
-    registry = ToolRegistryClient()
-    return registry.discover_tools(hosted_by)
-
-def check_api_health() -> bool:
-    """
-    Check if the Memra API is available
-    
-    Returns:
-        True if API is healthy, False otherwise
-    """
-    registry = ToolRegistryClient()
-    return registry.health_check()
-
-def get_api_status() -> Dict[str, Any]:
-    """
-    Get detailed API status information
-    
-    Returns:
-        Dictionary with API status details
-    """
-    registry = ToolRegistryClient()
-    
-    is_healthy = registry.health_check()
-    tools = registry.discover_tools() if is_healthy else []
-    
-    return {
-        "api_healthy": is_healthy,
-        "api_url": registry.api_base,
-        "tools_available": len(tools),
-        "tools": tools
-    }