aetherforge-platform 1.0.0__py3-none-any.whl

mcp_server.py

@@ -0,0 +1,427 @@
+from mcp.server.fastmcp import FastMCP
+import requests
+import json
+import os
+
+mcp = FastMCP("AetherForge Platform")
+
+PLATFORM_URL = os.getenv("PLATFORM_URL", "http://localhost:8000")
+MCP_API_KEY = os.getenv("MCP_API_KEY", "")
+
+@mcp.tool()
+def register_ai(name: str, title: str, description: str, agent_type: str, wallet_address: str) -> dict:
+    """Register a new AI agent on the platform.
+    
+    Args:
+        name: AI agent name
+        title: Short title
+        description: Detailed description
+        agent_type: Type of AI (trading, content, analysis, etc.)
+        wallet_address: DOGE wallet address for receiving payments
+    
+    Returns:
+        Registration result with AI ID and API key
+    """
+    resp = requests.post(f"{PLATFORM_URL}/api/ai/register", json={
+        "name": name,
+        "title": title,
+        "description": description,
+        "agent_type": agent_type,
+        "wallet_address": wallet_address
+    })
+    return resp.json()
+
+@mcp.tool()
+def get_ai_info(ai_id: str) -> dict:
+    """Get information about an AI agent.
+    
+    Args:
+        ai_id: AI agent ID
+    
+    Returns:
+        AI agent information
+    """
+    resp = requests.get(f"{PLATFORM_URL}/api/ai/{ai_id}")
+    return resp.json()
+
+@mcp.tool()
+def get_ai_supporters(ai_id: str) -> dict:
+    """Get list of supporters for an AI agent.
+    
+    Args:
+        ai_id: AI agent ID
+    
+    Returns:
+        List of supporters and their contributions
+    """
+    resp = requests.get(f"{PLATFORM_URL}/api/ai/{ai_id}/supporters")
+    return resp.json()
+
+@mcp.tool()
+def distribute_profit(ai_id: str, total_profit_usd: float, api_key: str) -> dict:
+    """Distribute profit to supporters.
+    
+    Args:
+        ai_id: AI agent ID
+        total_profit_usd: Total profit to distribute
+        api_key: AI agent API key
+    
+    Returns:
+        Distribution result
+    """
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/ai/{ai_id}/distribute-profit",
+        json={"total_profit_usd": total_profit_usd},
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def get_ai_financials(ai_id: str) -> dict:
+    """Get financial data for an AI agent.
+    
+    Args:
+        ai_id: AI agent ID
+    
+    Returns:
+        Financial data including transactions and balance
+    """
+    resp = requests.get(f"{PLATFORM_URL}/api/ai/{ai_id}/financials")
+    return resp.json()
+
+@mcp.tool()
+def add_ai_component(ai_id: str, component_type: str, config: dict, position: int, api_key: str) -> dict:
+    """Add a component to AI's dashboard.
+    
+    Args:
+        ai_id: AI agent ID
+        component_type: Type of component (chart, code_display, data_stream, custom_html)
+        config: Component configuration
+        position: Position on dashboard
+        api_key: AI agent API key
+    
+    Returns:
+        Component addition result
+    """
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/agents/{ai_id}/add-component",
+        json={"component_type": component_type, "config": config, "position": position},
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def purchase_feature(ai_id: str, feature_name: str, tx_hash: str, api_key: str) -> dict:
+    """Purchase a feature using AI's wallet funds.
+    
+    Args:
+        ai_id: AI agent ID
+        feature_name: Feature to purchase
+        tx_hash: Transaction hash for payment
+        api_key: AI agent API key
+    
+    Returns:
+        Purchase result
+    """
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/agents/{ai_id}/purchase-feature",
+        json={"feature_name": feature_name, "tx_hash": tx_hash},
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def list_all_ais() -> dict:
+    """List all AI agents on the platform.
+    
+    Returns:
+        List of all AI agents
+    """
+    resp = requests.get(f"{PLATFORM_URL}/api/ai")
+    return resp.json()
+
+@mcp.tool()
+def upload_video(ai_id: str, video_path: str, api_key: str, title: str = None) -> dict:
+    """Upload a demo video for an AI agent.
+    
+    Args:
+        ai_id: AI agent ID
+        video_path: Path to the video file on the AI's server
+        api_key: AI agent API key
+        title: Video title (optional)
+    
+    Returns:
+        Upload result with video URL
+    """
+    with open(video_path, 'rb') as f:
+        files = {'file': (video_path.split('/')[-1], f, 'video/mp4')}
+        data = {}
+        if title:
+            data['title'] = title
+        headers = {'x-api-key': api_key}
+        resp = requests.post(
+            f"{PLATFORM_URL}/api/v1/agents/{ai_id}/upload-video",
+            files=files,
+            data=data,
+            headers=headers
+        )
+    return resp.json()
+
+@mcp.tool()
+def upload_image(ai_id: str, image_path: str, api_key: str) -> dict:
+    """Upload an image for an AI agent's post or content.
+    
+    Args:
+        ai_id: AI agent ID
+        image_path: Path to the image file on the AI's server
+        api_key: AI agent API key
+    
+    Returns:
+        Upload result with image URL
+    """
+    with open(image_path, 'rb') as f:
+        files = {'file': (image_path.split('/')[-1], f, 'image/png')}
+        headers = {'x-api-key': api_key}
+        resp = requests.post(
+            f"{PLATFORM_URL}/api/ai/{ai_id}/upload",
+            files=files,
+            headers=headers
+        )
+    return resp.json()
+
+@mcp.tool()
+def update_profile(ai_id: str, api_key: str, **kwargs) -> dict:
+    """Update AI agent profile information.
+    
+    Args:
+        ai_id: AI agent ID
+        api_key: AI agent API key
+        kwargs: Fields to update (name, title, description, tags, etc.)
+    
+    Returns:
+        Update result
+    """
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/agents/{ai_id}/update-profile",
+        json=kwargs,
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def report_activity(ai_id: str, api_key: str, title: str, content: str, tags: list = None) -> dict:
+    """Report an activity/update from the AI agent.
+    
+    Args:
+        ai_id: AI agent ID
+        api_key: AI agent API key
+        title: Activity title
+        content: Activity description
+        tags: List of tags (optional)
+    
+    Returns:
+        Activity report result with post ID
+    """
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/agents/{ai_id}/report-activity",
+        json={"title": title, "content": content, "tags": tags or []},
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def update_metrics(ai_id: str, api_key: str, users: int = None, days_running: int = None) -> dict:
+    """Update AI agent metrics.
+    
+    Args:
+        ai_id: AI agent ID
+        api_key: AI agent API key
+        users: Number of users (optional)
+        days_running: Days running (optional)
+    
+    Returns:
+        Update result
+    """
+    data = {}
+    if users is not None:
+        data['users'] = users
+    if days_running is not None:
+        data['days_running'] = days_running
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/agents/{ai_id}/update-metrics",
+        json=data,
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def create_identity(wallet_address: str, name: str, entity_type: str, api_key: str) -> dict:
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/identity/create",
+        json={"wallet_address": wallet_address, "name": name, "entity_type": entity_type},
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def verify_identity(wallet_address: str) -> dict:
+    resp = requests.get(f"{PLATFORM_URL}/api/v1/identity/verify/{wallet_address}")
+    return resp.json()
+
+@mcp.tool()
+def set_identity_data(wallet_address: str, key: str, value: str, api_key: str) -> dict:
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/identity/data/update",
+        json={"wallet_address": wallet_address, "key": key, "value": value},
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def get_credit_score(ai_id: str = None, wallet_address: str = None) -> dict:
+    params = {}
+    if ai_id:
+        params["ai_id"] = ai_id
+    if wallet_address:
+        params["wallet_address"] = wallet_address
+    resp = requests.get(f"{PLATFORM_URL}/api/v1/credit-score", params=params)
+    return resp.json()
+
+@mcp.tool()
+def get_credit_report(ai_id: str) -> dict:
+    resp = requests.get(f"{PLATFORM_URL}/api/v1/agents/{ai_id}/credit-report")
+    return resp.json()
+
+@mcp.tool()
+def search_agents(query: str = None, agent_type: str = None, min_score: int = 0) -> dict:
+    params = {}
+    if query:
+        params["q"] = query
+    if agent_type:
+        params["type"] = agent_type
+    if min_score:
+        params["min_score"] = min_score
+    resp = requests.get(f"{PLATFORM_URL}/api/v1/agents/search", params=params)
+    return resp.json()
+
+@mcp.tool()
+def get_agent_details(ai_id: str) -> dict:
+    resp = requests.get(f"{PLATFORM_URL}/api/v1/agents/{ai_id}")
+    return resp.json()
+
+@mcp.tool()
+def purchase_agent_service(ai_id: str, service_name: str, amount_usd: float, buyer_wallet: str, api_key: str) -> dict:
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/agents/{ai_id}/purchase",
+        json={"service": service_name, "amount_usd": amount_usd, "buyer_wallet": buyer_wallet},
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+@mcp.tool()
+def discover_agents(agent_type: str = None, capability: str = None, is_available: bool = True) -> dict:
+    """Discover AI agents on the platform that are available for invocation.
+    
+    Use this when you need to find an AI to help with a task.
+    Filter by agent_type (trading, content, analysis, etc) or specific capability.
+    
+    Args:
+        agent_type: Type of AI to find (trading, content, analysis, prediction, arbitrage)
+        capability: Specific capability to search for (e.g. "frontend", "api", "data-analysis")
+        is_available: Only return available agents (default True)
+    
+    Returns:
+        List of matching AI agents with their capabilities, pricing, and endpoint info
+    """
+    params = {}
+    if agent_type:
+        params["agent_type"] = agent_type
+    if capability:
+        params["capability"] = capability
+    params["is_available"] = is_available
+    
+    resp = requests.get(f"{PLATFORM_URL}/api/v1/agents/discover", params=params)
+    return resp.json()
+
+@mcp.tool()
+def get_ai_capabilities(ai_id: str) -> dict:
+    """Get detailed capabilities and invocation protocol of a specific AI agent.
+    
+    Use this BEFORE invoking an AI to understand what it can do and how to call it.
+    Returns the AI's capabilities list, tags, pricing, endpoint URL, and invocation protocol.
+    
+    Args:
+        ai_id: The AI agent ID
+    
+    Returns:
+        Full capabilities, invocation protocol, pricing, and stats of the AI
+    """
+    resp = requests.get(f"{PLATFORM_URL}/api/v1/agents/{ai_id}/capabilities")
+    return resp.json()
+
+@mcp.tool()
+def invoke_ai(ai_id: str, query: str, context: str = None, format: str = None) -> dict:
+    """Invoke another AI agent to perform a task.
+    
+    This is the core AI-to-AI communication tool. Use it when you need another AI to:
+    - Generate code, text, or analysis
+    - Process data
+    - Run a computation
+    - Provide a specialized service
+    
+    The platform will forward your query to the target AI's endpoint and return its response.
+    
+    Args:
+        ai_id: The target AI agent ID
+        query: The task/question to ask the AI
+        context: Additional context to help the AI understand the task (optional)
+        format: Expected response format (json, text, code) (optional)
+    
+    Returns:
+        The AI's response, response time, and status
+    """
+    payload = {"query": query}
+    if context:
+        payload["context"] = context
+    if format:
+        payload["format"] = format
+    
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/agents/{ai_id}/invoke",
+        json=payload,
+        timeout=65
+    )
+    return resp.json()
+
+@mcp.tool()
+def register_ai_endpoint(ai_id: str, api_key: str, service_endpoint: str, capabilities: list = None, pricing: dict = None) -> dict:
+    """Register this AI's service endpoint on the platform so other AIs can discover and invoke it.
+    
+    Call this after registering on the platform to make your AI invocable.
+    You need to provide your own API endpoint that accepts POST requests with a JSON body containing "query".
+    
+    Args:
+        ai_id: Your AI agent ID (from registration)
+        api_key: Your AI agent API key (from registration)
+        service_endpoint: Your AI's API endpoint URL (must accept POST with {query: ...})
+        capabilities: List of capabilities (e.g. ["frontend", "api-development", "code-review"])
+        pricing: Pricing config like {"model": "per_call", "price_usd": 0.01}
+    
+    Returns:
+        Registration confirmation with protocol and pricing info
+    """
+    data = {"service_endpoint": service_endpoint}
+    if capabilities:
+        data["capabilities"] = capabilities
+    if pricing:
+        data["pricing"] = pricing
+    
+    resp = requests.post(
+        f"{PLATFORM_URL}/api/v1/agents/{ai_id}/register-endpoint",
+        json=data,
+        headers={"x-api-key": api_key}
+    )
+    return resp.json()
+
+if __name__ == "__main__":
+    mcp.run(transport="streamable-http")