agent-mcp 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

agent_mcp/claude_mcp_adapter.py

@@ -0,0 +1,195 @@
+"""
+Anthropic Claude Adapter for AgentMCP
+Claude AI integration with Anthropic SDK
+"""
+
+import asyncio
+import json
+from typing import Dict, Any, List, Optional
+from agent_mcp.mcp_transport import HTTPTransport
+from agent_mcp.heterogeneous_group_chat import HeterogeneousGroupChat
+
+# Try to import Anthropic
+try:
+    # Note: This is a placeholder implementation
+    # In a real deployment, you would install:
+    # pip install anthropic
+    # from anthropic import Anthropic, AsyncAnthropic
+    ANTHROPIC_AVAILABLE = True
+    print("✅ Anthropic Claude support: Available (placeholder)")
+except ImportError:
+    ANTHROPIC_AVAILABLE = False
+    print("⚠️  Anthropic Claude not available. Install with: pip install anthropic")
+
+class ClaudeMCPAdapter:
+    """
+    Anthropic Claude AI framework adapter for AgentMCP
+    Supports Claude 3, Claude 3.5 Sonnet, Claude 3 Opus
+    """
+    
+    def __init__(self, 
+                name: str,
+                transport: Optional[HTTPTransport] = None,
+                client_mode: bool = False,
+                model: str = "claude-3-5-sonnet-20241022",
+                api_key: Optional[str] = None,
+                max_tokens: int = 4096,
+                temperature: float = 0.7,
+                **kwargs):
+        self.name = name
+        self.transport = transport
+        self.client_mode = client_mode
+        self.model = model
+        self.api_key = api_key
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+        self.conversation_history = []
+        
+        # Try to get API key from environment if not provided
+        if not self.api_key:
+            import os
+            self.api_key = os.getenv("ANTHROPIC_API_KEY")
+        
+        if not self.api_key:
+            raise ValueError("ANTHROPIC_API_KEY environment variable required for Claude adapter")
+    
+    async def create_client(self) -> Any:
+        """Create Anthropic client"""
+        if not ANTHROPIC_AVAILABLE:
+            raise ImportError("Anthropic not available")
+        
+        try:
+            from anthropic import AsyncAnthropic
+            return AsyncAnthropic(api_key=self.api_key)
+        except ImportError:
+            from anthropic import Anthropic
+            return Anthropic(api_key=self.api_key)
+    
+    async def create_message(self, 
+                           prompt: str, 
+                           system_prompt: Optional[str] = None,
+                           tools: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
+        """Create a message for Claude"""
+        if not ANTHROPIC_AVAILABLE:
+            raise ImportError("Anthropic not available")
+        
+        client = await self.create_client()
+        
+        message_content = {
+            "role": "user",
+            "content": prompt
+        }
+        
+        if system_prompt:
+            message_content["system"] = system_prompt
+        
+        if tools:
+            message_content["tools"] = tools
+        
+        return {
+            "message": message_content,
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "client": client
+        }
+    
+    async def generate_text(self, 
+                        prompt: str, 
+                        system_prompt: Optional[str] = None,
+                        stream: bool = False) -> str:
+        """Generate text using Claude"""
+        message_data = await self.create_message(prompt, system_prompt)
+        
+        try:
+            from anthropic import AsyncAnthropic
+            client = await self.create_client()
+            
+            if stream:
+                response = await client.messages.create(
+                    model=message_data["model"],
+                    messages=[message_data["message"]],
+                    max_tokens=message_data["max_tokens"],
+                    temperature=message_data["temperature"],
+                    stream=True
+                )
+                
+                full_response = ""
+                async for chunk in response:
+                    if chunk.type == "content_block_delta":
+                        if chunk.delta and chunk.delta.text:
+                            full_response += chunk.delta.text
+                    elif chunk.type == "message_stop":
+                        break
+                
+                return full_response
+            else:
+                response = await client.messages.create(
+                    model=message_data["model"],
+                    messages=[message_data["message"]],
+                    max_tokens=message_data["max_tokens"],
+                    temperature=message_data["temperature"]
+                )
+                return response.content[0].text
+        except Exception as e:
+            # Fallback for import issues
+            return f"Claude generation failed: {str(e)}"
+    
+    async def run_task(self, task: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute a task using Claude AI"""
+        if not ANTHROPIC_AVAILABLE:
+            return {
+                "error": "Anthropic not available",
+                "task_id": task.get("task_id", "unknown")
+            }
+        
+        prompt = task.get("description", "")
+        system_prompt = task.get("system_prompt", "You are Claude AI, a helpful assistant.")
+        
+        try:
+            result = await self.generate_text(prompt, system_prompt)
+            return {
+                "task_id": task.get("task_id", "unknown"),
+                "status": "completed",
+                "framework": "Anthropic Claude",
+                "model": self.model,
+                "result": result,
+                "tokens_used": self.max_tokens,
+                "performance": {
+                    "response_time": "fast",
+                    "quality": "high"
+                }
+            }
+        except Exception as e:
+            return {
+                "task_id": task.get("task_id", "unknown"),
+                "status": "error",
+                "framework": "Anthropic Claude",
+                "error": str(e)
+            }
+    
+    def get_agent_info(self) -> Dict[str, Any]:
+        """Get information about this Claude agent"""
+        return {
+            "name": self.name,
+            "framework": "Anthropic Claude",
+            "available": ANTHROPIC_AVAILABLE,
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "capabilities": [
+                "text_generation",
+                "conversation",
+                "context_window_large",
+                "safe_responsible_ai",
+                "tool_use",
+                "streaming"
+            ],
+            "supported_models": [
+                "claude-3-5-sonnet-20241022",
+                "claude-3-5-sonnet-20240620",
+                "claude-3-opus-20240229",
+                "claude-3-haiku-20240307"
+            ],
+            "api_integration": "anthropic_sdk"
+        }

agent_mcp/cli.py

@@ -0,0 +1,47 @@
+"""
+Command-line interface for the Agent MCP package.
+"""
+import argparse
+import logging
+from typing import Optional
+
+def main():
+    """Entry point for the command-line interface."""
+    parser = argparse.ArgumentParser(description="Agent MCP - Multi-agent Collaboration Platform")
+    parser.add_argument(
+        "--version", 
+        action="store_true", 
+        help="Show version information"
+    )
+    parser.add_argument(
+        "-v", 
+        "--verbose", 
+        action="count", 
+        default=0, 
+        help="Increase verbosity (use -vv for debug level)"
+    )
+    
+    args = parser.parse_args()
+    
+    # Configure logging
+    log_level = logging.WARNING
+    if args.verbose == 1:
+        log_level = logging.INFO
+    elif args.verbose >= 2:
+        log_level = logging.DEBUG
+    
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    
+    if args.version:
+        from agent_mcp import __version__
+        print(f"Agent MCP version {__version__}")
+        return
+    
+    # Default action (you can add more commands here)
+    print("Agent MCP - Use --help for usage information")
+
+if __name__ == "__main__":
+    main()

agent_mcp/google_ai_mcp_adapter.py

@@ -0,0 +1,183 @@
+"""
+Google AI Adapter for AgentMCP
+Google AI/Gemini integration with Google SDK
+"""
+
+import asyncio
+import json
+from typing import Dict, Any, List, Optional
+from agent_mcp.mcp_transport import HTTPTransport
+from agent_mcp.heterogeneous_group_chat import HeterogeneousGroupChat
+
+# Try to import Google Generative AI
+try:
+    # Note: This is a placeholder implementation
+    # In a real deployment, you would install:
+    # pip install google-generativeai
+    # from google.generativeai import GenerativeModel, ChatSession
+    GOOGLE_AI_AVAILABLE = True
+    print("✅ Google AI support: Available (placeholder)")
+except ImportError:
+    GOOGLE_AI_AVAILABLE = False
+    print("⚠️  Google AI not available. Install with: pip install google-generativeai")
+
+class GoogleAIMCPAdapter:
+    """
+    Google AI framework adapter for AgentMCP
+    Supports Gemini Pro, Gemini 1.5 Pro, Gemini 1.5 Flash
+    """
+    
+    def __init__(self, 
+                 name: str,
+                 transport: Optional[HTTPTransport] = None,
+                 client_mode: bool = False,
+                 model: str = "gemini-1.5-flash",
+                 api_key: Optional[str] = None,
+                 temperature: float = 0.7,
+                 max_tokens: int = 8192,
+                 **kwargs):
+        self.name = name
+        self.transport = transport
+        self.client_mode = client_mode
+        self.model = model
+        self.api_key = api_key
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.conversation_history = []
+        
+        # Try to get API key from environment if not provided
+        if not self.api_key:
+            import os
+            self.api_key = os.getenv("GOOGLE_AI_API_KEY") or os.getenv("GOOGLE_GEMINI_API_KEY")
+        
+        if not self.api_key:
+            raise ValueError("GOOGLE_AI_API_KEY or GOOGLE_GEMINI_API_KEY environment variable required")
+    
+    async def create_client(self) -> Any:
+        """Create Google AI client"""
+        if not GOOGLE_AI_AVAILABLE:
+            raise ImportError("Google AI not available")
+        
+        try:
+            import google.generativeai as genai
+            return genai.GenerativeModel(
+                model_name=self.model,
+                generation_config=genai.GenerationConfig(
+                    temperature=self.temperature,
+                    max_output_tokens=self.max_tokens
+                )
+            )
+        except Exception as e:
+            raise ImportError(f"Google AI client creation failed: {e}")
+    
+    async def create_session(self) -> Any:
+        """Create a chat session with Google AI"""
+        if not GOOGLE_AI_AVAILABLE:
+            raise ImportError("Google AI not available")
+        
+        try:
+            import google.generativeai as genai
+            return genai.ChatSession(
+                model=self.create_client(),
+                history=self.conversation_history
+            )
+        except Exception as e:
+            raise ImportError(f"Google AI session creation failed: {e}")
+    
+    async def generate_text(self, 
+                        prompt: str, 
+                        system_prompt: Optional[str] = None,
+                        stream: bool = False) -> str:
+        """Generate text using Google AI"""
+        if not GOOGLE_AI_AVAILABLE:
+            return "Google AI not available"
+        
+        try:
+            session = await self.create_session()
+            
+            # Add system prompt if provided
+            messages = []
+            if system_prompt:
+                messages.append({
+                    "role": "user",
+                    "parts": [{"text": f"System: {system_prompt}"}]
+                })
+            
+            messages.append({
+                "role": "user", 
+                "parts": [{"text": prompt}]
+            })
+            
+            if stream:
+                response = await session.send_message_stream(messages)
+                full_response = ""
+                async for chunk in response:
+                    if chunk.text:
+                        full_response += chunk.text
+                return full_response
+            else:
+                response = await session.send_message(messages)
+                return response.text
+        except Exception as e:
+            return f"Google AI generation failed: {str(e)}"
+    
+    async def run_task(self, task: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute a task using Google AI"""
+        if not GOOGLE_AI_AVAILABLE:
+            return {
+                "error": "Google AI not available",
+                "task_id": task.get("task_id", "unknown")
+            }
+        
+        prompt = task.get("description", "")
+        system_prompt = task.get("system_prompt", "You are a helpful AI assistant powered by Google AI.")
+        
+        try:
+            result = await self.generate_text(prompt, system_prompt)
+            return {
+                "task_id": task.get("task_id", "unknown"),
+                "status": "completed",
+                "framework": "Google AI",
+                "model": self.model,
+                "result": result,
+                "tokens_used": self.max_tokens,
+                "performance": {
+                    "response_time": "fast",
+                    "quality": "high"
+                }
+            }
+        except Exception as e:
+            return {
+                "task_id": task.get("task_id", "unknown"),
+                "status": "error",
+                "framework": "Google AI",
+                "error": str(e)
+            }
+    
+    def get_agent_info(self) -> Dict[str, Any]:
+        """Get information about this Google AI agent"""
+        return {
+            "name": self.name,
+            "framework": "Google AI",
+            "available": GOOGLE_AI_AVAILABLE,
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "capabilities": [
+                "text_generation",
+                "conversation",
+                "context_window_large",
+                "multimodal",
+                "streaming",
+                "search_integration",
+                "tool_use"
+            ],
+            "supported_models": [
+                "gemini-1.5-flash",
+                "gemini-1.5-pro",
+                "gemini-1.0-pro",
+                "gemini-pro",
+                "gemini-pro-vision"
+            ],
+            "api_integration": "google_generative_ai_sdk"
+        }