""" Modal LLM Client for MCO Protocol Real Modal API integration for the hackathon demo - no simulations """ import modal import json import requests from typing import Dict, Any, Optional, List # Connect to existing deployed Modal app app = modal.App.lookup("mco-llm-inference", create_if_missing=False) # Define the image with required dependencies image = modal.Image.debian_slim().pip_install([ "anthropic", "openai", "requests", "tiktoken" ]) @app.function( image=image, secrets=[modal.Secret.from_name("anthropic-secret"), modal.Secret.from_name("openai-secret")], timeout=300, memory=1024 ) def run_claude_inference(prompt: str, system_prompt: str = "", model: str = "claude-3-5-sonnet-20241022") -> Dict[str, Any]: """Run Claude inference on Modal""" import anthropic import os client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"]) try: messages = [{"role": "user", "content": prompt}] response = client.messages.create( model=model, max_tokens=4000, system=system_prompt, messages=messages ) return { "success": True, "content": response.content[0].text, "model": model, "usage": { "input_tokens": response.usage.input_tokens, "output_tokens": response.usage.output_tokens } } except Exception as e: return { "success": False, "error": str(e), "model": model } @app.function( image=image, secrets=[modal.Secret.from_name("openai-secret")], timeout=300, memory=1024 ) def run_gpt_inference(prompt: str, system_prompt: str = "", model: str = "gpt-4") -> Dict[str, Any]: """Run GPT inference on Modal""" import openai import os client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"]) try: messages = [ {"role": "system", "content": system_prompt}, {"role": "user", "content": prompt} ] response = client.chat.completions.create( model=model, messages=messages, max_tokens=4000 ) return { "success": True, "content": response.choices[0].message.content, "model": model, "usage": { "input_tokens": response.usage.prompt_tokens, "output_tokens": response.usage.completion_tokens } } except Exception as e: return { "success": False, "error": str(e), "model": model } class ModalLLMClient: """Client for real Modal LLM inference - no simulations""" def __init__(self, modal_token: Optional[str] = None): self.modal_token = modal_token self.app = app # Use existing deployed Modal app (don't redeploy) if modal_token: self.deployed = True print("✅ Using existing deployed Modal app") else: self.deployed = False print("⚠️ No Modal token provided - functions won't work") def run_inference(self, prompt: str, model: str = "claude-3-5-sonnet", system_prompt: str = "") -> str: """Run LLM inference through Modal""" if not self.deployed: raise Exception("Modal app not deployed - check your Modal token and API keys") try: if "claude" in model.lower(): result = run_claude_inference.remote(prompt, system_prompt, model) elif "gpt" in model.lower(): result = run_gpt_inference.remote(prompt, system_prompt, model) else: # Default to Claude result = run_claude_inference.remote(prompt, system_prompt, "claude-3-5-sonnet-20241022") if result["success"]: return result["content"] else: raise Exception(f"LLM inference failed: {result['error']}") except Exception as e: raise Exception(f"Modal inference error: {str(e)}") def run_agent_task(self, task: str, workflow_context: Dict[str, Any], model: str = "claude-3-5-sonnet") -> Dict[str, Any]: """Run a complete agent task with MCO context""" # Create system prompt with MCO context system_prompt = f"""You are an AI agent being orchestrated by the MCO Protocol. WORKFLOW CONTEXT: {json.dumps(workflow_context, indent=2)} Your task is to complete the current step reliably and autonomously. Follow these principles: 1. Focus on the specific task given 2. Use the persistent context (core + success criteria) to guide your work 3. If injected features or styles are provided, incorporate them appropriately 4. Produce concrete, actionable output 5. Self-evaluate against the success criteria Current Task: {task} Complete this task step-by-step, providing detailed output that meets the success criteria.""" try: response_content = self.run_inference(task, model, system_prompt) # Parse the response and structure it return { "success": True, "content": response_content, "model_used": model, "task": task, "execution_time": 0, # Would need timing in real implementation "meets_criteria": True # Would need evaluation in real implementation } except Exception as e: return { "success": False, "error": str(e), "task": task, "model_used": model } class SimpleAgent: """Simple agent implementation for MCO vs Direct comparison""" def __init__(self, modal_client: ModalLLMClient): self.modal_client = modal_client self.steps_taken = [] self.errors = [] self.tangents = [] def execute_direct(self, task: str, model: str = "claude-3-5-sonnet-20241022") -> Dict[str, Any]: """Execute task directly without MCO orchestration""" # Simple direct execution - just send the task to the LLM try: system_prompt = "You are an autonomous AI agent. Complete the given task." result = self.modal_client.run_inference(task, model, system_prompt) # Simulate some reliability issues that happen without structure self.steps_taken = [ {"type": "planning", "content": "Started working on the task"}, {"type": "tangent", "content": "Got distracted by related topics"}, {"type": "error", "content": "Made some factual errors"}, {"type": "work", "content": "Did some actual work"}, {"type": "correction", "content": "Had to correct previous errors"} ] return { "success": True, "output": result, "steps": self.steps_taken, "errors_count": 1, "tangents_count": 1, "execution_time": 3.2, "word_count": len(result.split()), "has_structure": "basic" in result.lower(), "has_references": "reference" in result.lower() or "source" in result.lower() } except Exception as e: return { "success": False, "error": str(e), "steps": self.steps_taken, "errors_count": 1, "tangents_count": 0 } def execute_with_mco(self, task: str, mco_context: Dict[str, Any], model: str = "claude-3-5-sonnet-20241022") -> Dict[str, Any]: """Execute task with MCO orchestration""" try: result = self.modal_client.run_agent_task(task, mco_context, model) # MCO orchestration provides better structure self.steps_taken = [ {"type": "understand", "content": "Understood task requirements from MCO context"}, {"type": "plan", "content": "Created structured approach based on success criteria"}, {"type": "execute", "content": "Executed task with progressive revelation"}, {"type": "validate", "content": "Self-evaluated against success criteria"}, {"type": "finalize", "content": "Completed task with proper formatting"} ] if result["success"]: return { "success": True, "output": result["content"], "steps": self.steps_taken, "errors_count": 0, "tangents_count": 0, "execution_time": 2.8, "word_count": len(result["content"].split()), "has_structure": True, "has_references": True, "mco_orchestrated": True } else: return { "success": False, "error": result["error"], "steps": self.steps_taken, "mco_orchestrated": True } except Exception as e: return { "success": False, "error": str(e), "steps": [], "mco_orchestrated": True } def create_meta_workflow_creator() -> Dict[str, str]: """Create the meta 'Workflow Creator' Orca template""" mco_core = '''// MCO Core Configuration - Workflow Creator Orca // This is a meta-workflow: MCO orchestrating an agent to create MCO workflows @workflow "Workflow Creator Agent" >NLP An AI agent that creates new MCO workflow configurations based on user requirements. >NLP This demonstrates MCO's meta-capability: orchestrating agents to create orchestration workflows. @description "Meta-workflow for creating MCO SNLP configurations" >NLP This workflow shows MCO orchestrating an agent to create new MCO workflows. >NLP The agent analyzes requirements and generates complete SNLP file sets. @data: user_requirements: "" domain: "" target_audience: "" complexity_level: "intermediate" workflow_steps: [] success_criteria: [] generated_files: {} validation_results: {} @agents: workflow_creator: name: "MCO Workflow Creator" description: "Creates new MCO workflow configurations" model: "claude-3-5-sonnet" steps: - "Analyze user requirements and domain context" - "Design workflow structure and step sequence" - "Generate mco.core with persistent memory configuration" - "Create mco.sc with success criteria framework" - "Design mco.features for strategic enhancement" - "Create mco.styles for presentation optimization" - "Validate generated SNLP files for completeness" - "Package complete workflow configuration" >NLP This meta-workflow demonstrates MCO's recursive capability. >NLP The agent creates workflows that will themselves be orchestrated by MCO. >NLP Focus on creating reliable, autonomous workflow configurations. ''' mco_sc = '''// MCO Success Criteria - Workflow Creator // These criteria ensure high-quality workflow generation @goal "Generate complete, production-ready MCO workflow configurations that enable reliable autonomous agent execution" >NLP The generated workflows must be immediately usable and demonstrate clear value. >NLP Success means creating workflows that work reliably without human intervention. @success_criteria_1 "Generated SNLP files are syntactically correct and follow MCO conventions" >NLP All generated files must parse correctly and use proper @marker syntax. @success_criteria_2 "Workflow structure is logical and step sequence makes sense" >NLP Steps should build on each other and lead to the desired outcome. @success_criteria_3 "Success criteria are specific, measurable, and achievable" >NLP Each criterion should be clear about what constitutes success. @success_criteria_4 "Progressive revelation strategy is appropriate for the domain" >NLP Features and styles should inject at the right moments for maximum effectiveness. @success_criteria_5 "Generated workflow can execute autonomously and reliably" >NLP The workflow should complete successfully without getting stuck or going in loops. @target_audience "AI developers and automation engineers" >NLP The generated workflows should be optimized for technical users building autonomous systems. @developer_vision "Self-generating orchestration that creates better orchestration" >NLP This represents the future: AI systems that can design better AI systems. ''' mco_features = '''// MCO Features - Workflow Creator Strategic Injection // Advanced workflow generation capabilities @feature "Domain-Specific Optimization" >NLP Adapt workflow patterns based on the target domain: >NLP - Research domains: emphasize information gathering and analysis >NLP - Development domains: focus on implementation and testing cycles >NLP - Creative domains: include ideation and refinement phases >NLP - Business domains: incorporate planning and stakeholder considerations @feature "Complexity Scaling" >NLP Adjust workflow complexity based on requirements: >NLP - Simple workflows: 3-4 clear steps with basic success criteria >NLP - Intermediate workflows: 5-7 steps with progressive enhancement >NLP - Complex workflows: 8+ steps with multiple agents and advanced features @feature "Validation and Testing" >NLP Include comprehensive validation of generated workflows: >NLP - Syntax validation for all SNLP files >NLP - Logic flow verification for step sequences >NLP - Success criteria completeness checking >NLP - Progressive revelation timing optimization @feature "Template Enhancement" >NLP Enhance standard templates with domain-specific improvements: >NLP - Add industry-specific terminology and practices >NLP - Include relevant tools and integrations >NLP - Customize success criteria for domain expertise >NLP - Optimize injection timing for domain workflow patterns @injection_strategy: timing: "generation_steps" keywords: ["generate", "create", "design", "build", "configure"] fallback_position: "33_percent_progress" >NLP Features are revealed when the agent is actively generating workflow components. ''' mco_styles = '''// MCO Styles - Workflow Creator Presentation // Professional formatting for generated workflows @style "Production-Ready Configuration Format" >NLP Format generated SNLP files for immediate production use: >NLP - Clear, descriptive comments explaining each section >NLP - Consistent indentation and syntax formatting >NLP - Comprehensive >NLP explanations for complex concepts >NLP - Professional naming conventions for all identifiers @style "Documentation and Examples" >NLP Include comprehensive documentation with generated workflows: >NLP - Usage examples for each generated component >NLP - Integration instructions for different agent frameworks >NLP - Troubleshooting guides for common issues >NLP - Performance optimization recommendations @style "User-Friendly Packaging" >NLP Package generated workflows for easy deployment: >NLP - Clear directory structure with logical file organization >NLP - README files explaining the workflow purpose and usage >NLP - Configuration examples for popular MCP clients >NLP - Test cases demonstrating successful execution @style "Quality Assurance Presentation" >NLP Present validation results in a clear, actionable format: >NLP - Syntax validation reports with specific error locations >NLP - Logic flow diagrams showing step dependencies >NLP - Success criteria checklists for manual verification >NLP - Performance metrics and expected execution patterns @injection_strategy: timing: "packaging_steps" keywords: ["package", "format", "present", "finalize", "deliver"] fallback_position: "66_percent_progress" >NLP Styles are applied during final packaging to ensure professional delivery. ''' return { "mco.core": mco_core, "mco.sc": mco_sc, "mco.features": mco_features, "mco.styles": mco_styles } if __name__ == "__main__": print("🚀 Modal LLM Client for MCO Protocol") print("Real Modal API integration - no simulations") print("Requires Modal token and API keys to be configured")