traia-iatp 0.1.1__py3-none-any.whl

traia_iatp/mcp/templates/mcp_health_check.py.j2

@@ -0,0 +1,150 @@
+#!/usr/bin/env python
+"""
+{{ api_name }} MCP Server Health Check Script
+
+This script properly connects to the {{ api_name }} MCP server and checks its health by:
+1. Establishing a session
+2. Requesting server info
+3. Listing available tools
+"""
+
+import sys
+import json
+import requests
+import argparse
+from typing import Dict, Any
+import uuid
+
+def create_mcp_session(base_url: str) -> Dict[str, Any]:
+    """Create an MCP session and return session info"""
+    # Generate a session ID
+    session_id = str(uuid.uuid4())
+    
+    # MCP requires specific headers for streamable-http
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+        "X-Session-ID": session_id
+    }
+    
+    return {"session_id": session_id, "headers": headers, "base_url": base_url}
+
+def send_mcp_request(session: Dict[str, Any], method: str, params: Dict = None) -> Dict[str, Any]:
+    """Send an MCP JSON-RPC request"""
+    request_data = {
+        "jsonrpc": "2.0",
+        "method": method,
+        "params": params or {},
+        "id": str(uuid.uuid4())
+    }
+    
+    try:
+        response = requests.post(
+            f"{session['base_url']}/mcp/",
+            json=request_data,
+            headers=session['headers'],
+            timeout=5
+        )
+        
+        # Handle both JSON and SSE responses
+        if response.headers.get('content-type', '').startswith('text/event-stream'):
+            # For SSE, we'd need to parse the event stream
+            return {"status": "ok", "message": "Server returned SSE stream"}
+        else:
+            return response.json()
+            
+    except requests.exceptions.RequestException as e:
+        return {"error": str(e)}
+
+def check_mcp_server_health(url: str) -> bool:
+    """Check if {{ api_name }} MCP server is healthy"""
+    print(f"🔍 Checking {{ api_name }} MCP server health at {url}")
+    
+    # Create session
+    session = create_mcp_session(url)
+    print(f"📝 Created session: {session['session_id']}")
+    
+    # Try to get server info
+    print("\n1️⃣ Testing server.info method...")
+    result = send_mcp_request(session, "server.info")
+    
+    if "error" in result and "session" not in str(result.get("error", "")):
+        print(f"❌ Server info failed: {result}")
+        return False
+    else:
+        print(f"✅ Server responded: {json.dumps(result, indent=2)[:200]}...")
+    
+    # Try to list tools
+    print("\n2️⃣ Testing tools/list method...")
+    result = send_mcp_request(session, "tools/list")
+    
+    if "error" in result and "session" not in str(result.get("error", "")):
+        print(f"❌ List tools failed: {result}")
+        return False
+    else:
+        print(f"✅ Tools list responded: {json.dumps(result, indent=2)[:200]}...")
+        
+        # Check if we have the expected tools
+        if "result" in result and "tools" in result["result"]:
+            tools = result["result"]["tools"]
+            tool_names = [tool.get("name", "") for tool in tools]
+            print(f"📋 Available tools: {', '.join(tool_names)}")
+            
+            # Check for expected tools
+            expected_tools = ["example_tool", "get_api_info"]
+            missing_tools = [tool for tool in expected_tools if tool not in tool_names]
+            
+            if missing_tools:
+                print(f"⚠️  Missing expected tools: {', '.join(missing_tools)}")
+            else:
+                print("✅ All expected {{ api_name }} tools are available!")
+    
+    # Alternative: Try connecting with CrewAI adapter
+    print("\n3️⃣ Testing CrewAI adapter connection...")
+    try:
+        from crewai_tools import MCPServerAdapter
+        
+        server_params = {
+            "url": f"{url}/mcp/",
+            "transport": "streamable-http"
+        }
+        
+        with MCPServerAdapter(server_params) as mcp_tools:
+            tools = list(mcp_tools)
+            print(f"✅ CrewAI connected successfully! Found {len(tools)} tools")
+            
+            # Print first few tools
+            for i, tool in enumerate(tools[:3]):
+                print(f"   - {tool.name}")
+                
+            if len(tools) > 3:
+                print(f"   ... and {len(tools) - 3} more")
+                
+            return True
+            
+    except Exception as e:
+        print(f"⚠️  CrewAI adapter test failed: {e}")
+        # This might fail but server could still be healthy
+        
+    return True
+
+def main():
+    parser = argparse.ArgumentParser(description="Check {{ api_name }} MCP Server Health")
+    parser.add_argument("--url", default="http://localhost:8000", 
+                       help="{{ api_name }} MCP server URL (default: http://localhost:8000)")
+    args = parser.parse_args()
+    
+    print(f"🚀 {{ api_name }} MCP Server Health Check")
+    print(f"📍 Server URL: {args.url}")
+    print(f"📰 Expected tools: example_tool, get_api_info")
+    print("="*50)
+    
+    if check_mcp_server_health(args.url):
+        print("\n✅ {{ api_name }} MCP Server is healthy and responding!")
+        return 0
+    else:
+        print("\n❌ {{ api_name }} MCP Server health check failed!")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main()) 

traia_iatp/mcp/templates/pyproject.toml.j2

@@ -0,0 +1,26 @@
+[project]
+name = "{{ api_slug }}-mcp-server"
+version = "0.1.0"
+description = "MCP server for {{ api_name }} API{% if auth_description %} with authentication support{% endif %}"
+requires-python = ">=3.12"
+dependencies = [
+    "crewai-tools[mcp]>=0.48.0",
+    "fastmcp>=2.10.1",
+    "python-dotenv>=1.1.1",
+    "requests>=2.32.4",
+    "starlette>=0.46.2",
+    "retry>=0.9.2",
+{% if sdk_package %}
+    "{{ sdk_package }}",
+{% endif %}
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+include = [
+    "server.py",
+    "mcp_health_check.py",
+] 

traia_iatp/mcp/templates/run_local_docker.sh.j2

@@ -0,0 +1,94 @@
+#!/bin/bash
+
+# Script to build and run the {{ api_name }} MCP Server locally in Docker
+
+set -e  # Exit on error
+
+# Color codes for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Configuration
+IMAGE_NAME="{{ api_slug }}-mcp-server"
+CONTAINER_NAME="{{ api_slug }}-mcp-local"
+HOST_PORT=8000
+CONTAINER_PORT=8000
+
+echo -e "${BLUE}🚀 Building and running {{ api_name }} MCP Server...${NC}"
+echo
+
+# Check if Docker is installed
+if ! command -v docker &> /dev/null; then
+    echo -e "${RED}❌ Docker is not installed. Please install Docker first.${NC}"
+    exit 1
+fi
+
+# Stop and remove existing container if it exists
+if docker ps -a | grep -q $CONTAINER_NAME; then
+    echo -e "${YELLOW}🛑 Stopping existing container...${NC}"
+    docker stop $CONTAINER_NAME >/dev/null 2>&1 || true
+    docker rm $CONTAINER_NAME >/dev/null 2>&1 || true
+fi
+
+# Build the Docker image
+echo -e "${BLUE}🔨 Building Docker image...${NC}"
+docker build --no-cache -t $IMAGE_NAME .
+
+# Run the container
+echo -e "${BLUE}🏃 Starting container...${NC}"
+docker run -d \
+    --name $CONTAINER_NAME \
+    -p $HOST_PORT:$CONTAINER_PORT \
+    -e STAGE="${STAGE:-MAINNET}" \
+    -e LOG_LEVEL="${LOG_LEVEL:-INFO}" \
+{% if api_key_env_var %}
+    -e {{ api_key_env_var }}="{% raw %}${{% endraw %}{{ api_key_env_var }}{% raw %}}{% endraw %}" \
+{% endif %}
+    -e PORT="$CONTAINER_PORT" \
+    $IMAGE_NAME
+
+# Wait for the server to start
+echo -e "${YELLOW}⏳ Waiting for server to start...${NC}"
+sleep 3
+
+# Check if container is running
+if ! docker ps | grep -q $CONTAINER_NAME; then
+    echo -e "${RED}❌ Container failed to start. Checking logs:${NC}"
+    docker logs $CONTAINER_NAME
+    exit 1
+fi
+
+# Get container info
+CONTAINER_ID=$(docker ps -q -f name=$CONTAINER_NAME)
+CONTAINER_IP=$(docker inspect -f '{% raw %}{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}{% endraw %}' $CONTAINER_ID)
+
+# Output connection information
+echo
+echo -e "${GREEN}✅ {{ api_name }} MCP Server is running!${NC}"
+echo
+echo -e "${BLUE}📍 Connection Information:${NC}"
+echo -e "   Local URL:        ${GREEN}http://localhost:${HOST_PORT}/mcp${NC}"
+echo -e "   Container IP:     ${GREEN}${CONTAINER_IP}:${CONTAINER_PORT}${NC}"
+echo -e "   Container Name:   ${GREEN}${CONTAINER_NAME}${NC}"
+echo -e "   Container ID:     ${GREEN}${CONTAINER_ID:0:12}${NC}"
+echo
+echo -e "${BLUE}📝 Useful commands:${NC}"
+echo -e "   View logs:        ${YELLOW}docker logs -f ${CONTAINER_NAME}${NC}"
+echo -e "   Stop server:      ${YELLOW}docker stop ${CONTAINER_NAME}${NC}"
+echo -e "   Remove container: ${YELLOW}docker rm ${CONTAINER_NAME}${NC}"
+echo -e "   Shell access:     ${YELLOW}docker exec -it ${CONTAINER_NAME} /bin/bash${NC}"
+echo
+echo -e "${BLUE}🔌 MCP Server Endpoint:${NC}"
+echo -e "   ${GREEN}http://localhost:${HOST_PORT}/mcp${NC}"
+echo
+
+# Check if the server is responding
+echo -e "${YELLOW}🔍 Checking server health...${NC}"
+if curl -s -o /dev/null -w "%{http_code}" "http://localhost:${HOST_PORT}/mcp" | grep -q "200\|404\|405"; then
+    echo -e "${GREEN}✅ Server is responding!${NC}"
+else
+    echo -e "${YELLOW}⚠️  Server may still be starting up. Check logs with: docker logs -f ${CONTAINER_NAME}${NC}"
+fi 

traia_iatp/mcp/templates/server.py.j2

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+{{ api_name }} MCP Server{{ auth_description }}
+
+A Model Context Protocol server providing {{ api_description }}
+using the {{ api_name }} API{{ auth_details }}.
+"""
+
+import asyncio
+import logging
+import os
+import sys
+from typing import Dict, Any, Optional
+from datetime import datetime
+
+# Third-party imports
+import requests
+from fastmcp import FastMCP, Context
+from fastmcp.server.middleware import Middleware, MiddlewareContext
+from fastmcp.server.dependencies import get_http_request, get_context
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from retry import retry
+{% if sdk_package %}
+# {{ api_name }} SDK
+# TODO: Adjust the import based on the SDK documentation
+# Common patterns:
+#   - from {{ sdk_module }} import Client
+#   - from {{ sdk_module }} import {{ api_name }}Client  
+#   - import {{ sdk_module }}
+# Check the SDK docs for the correct import statement
+import {{ sdk_module }}
+{% endif %}
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('{{ logger_name }}')
+
+# Get stage from environment (useful for different API endpoints)
+STAGE = os.getenv("STAGE", "MAINNET").upper()
+
+
+{% if requires_auth %}
+class AuthMiddleware(Middleware):
+    """Middleware to extract and store API keys from Authorization headers."""
+    
+    async def on_request(self, context: MiddlewareContext, call_next):
+        """Extract bearer token on each request and bind to context state."""
+        try:
+            # Access the raw HTTP request
+            request: Request = get_http_request()
+            
+            # Debug: log all headers
+            logger.info(f"AuthMiddleware: Received request with headers: {dict(request.headers)}")
+            logger.info(f"AuthMiddleware: Method: {request.method}, URL: {request.url}")
+            
+            # Extract bearer token from Authorization header
+            auth = request.headers.get("Authorization", "")
+            token = auth[7:].strip() if auth.lower().startswith("bearer ") else None
+            
+            if not token:
+                # Check X-API-KEY header as alternative
+                token = request.headers.get("X-API-KEY", "")
+            
+            if token:
+                # Store the API key in the context state
+                # This will be accessible in tools via get_context()
+                if hasattr(context, 'state'):
+                    context.state.api_key = token
+                    logger.info(f"API key bound to context state: {token[:10]}...")
+                else:
+                    # Try to store it in the request state as fallback
+                    request.state.api_key = token
+                    logger.info(f"API key bound to request state: {token[:10]}...")
+            else:
+                logger.warning(f"No API key provided in request headers")
+            
+        except Exception as e:
+            # This might happen in non-HTTP transports or if get_http_request fails
+            logger.debug(f"Could not extract API key from request: {e}")
+            
+        # Proceed with the request (authentication check happens in the tools)
+        return await call_next(context)
+
+
+# Initialize FastMCP server with middleware
+mcp = FastMCP("{{ api_name }} MCP Server", middleware=[AuthMiddleware()])
+{% else %}
+# Initialize FastMCP server
+mcp = FastMCP("{{ api_name }} MCP Server")
+{% endif %}
+
+
+# Add health check endpoint using FastMCP's custom_route
+@mcp.custom_route("/health", methods=["GET"])
+async def health_check(request: Request) -> JSONResponse:
+    """Health check endpoint for container orchestration."""
+    return JSONResponse(
+        content={
+            "status": "healthy",
+            "service": "{{ api_slug }}-mcp-server",
+            "timestamp": datetime.now().isoformat()
+        }
+    )
+
+
+{% if requires_auth %}
+def get_session_api_key(context: Context) -> Optional[str]:
+    """Get the API key for the current session."""
+    try:
+        # Try to get the API key from the context state
+        # The middleware should have stored it there
+        if hasattr(context, 'state') and hasattr(context.state, 'api_key'):
+            return context.state.api_key
+        
+        # Fallback: try to get it from the current HTTP request
+        try:
+            request: Request = get_http_request()
+            if hasattr(request.state, 'api_key'):
+                return request.state.api_key
+        except Exception:
+            pass
+        
+        # If we're in a tool context, try to get the context using the dependency
+        try:
+            ctx = get_context()
+            if hasattr(ctx, 'state') and hasattr(ctx.state, 'api_key'):
+                return ctx.state.api_key
+        except Exception:
+            pass
+            
+    except Exception as e:
+        logger.debug(f"Could not retrieve API key from context: {e}")
+    
+    return None
+{% endif %}
+
+
+# TODO: Add your API-specific functions here
+# Use @retry decorator ONLY for external API calls (not internal functions):
+# @retry(tries=2, delay=1, backoff=2, jitter=(1, 3))
+# def call_{{ api_slug }}_api(query: str, api_key: str) -> Dict[str, Any]:
+#     """Call the {{ api_name }} API with the given query."""
+#     # You can use STAGE to determine which API endpoint to use:
+#     # base_url = "https://api-testnet.example.com" if STAGE == "TESTNET" else "https://api.example.com"
+#     # Implement your API logic here (HTTP requests, SDK calls, etc.)
+#     pass
+
+
+@mcp.tool()
+async def example_tool(
+    context: Context,
+    query: str
+) -> Dict[str, Any]:
+    """
+    Example tool for {{ api_name }} API.
+    
+    TODO: Replace this with your actual tool implementation.
+    
+    Args:
+        context: MCP context (injected automatically)
+        query: Query parameter
+        
+    Returns:
+        Dictionary with results
+    """
+    {% if requires_auth %}
+    # Check for API key
+    api_key = get_session_api_key(context)
+    if not api_key:
+        return {"error": "No API key found. Please authenticate with Authorization: Bearer YOUR_API_KEY"}
+    {% endif %}
+    
+    # TODO: Implement your tool logic here
+    return {
+        "status": "success",
+        "message": "This is a placeholder. Implement your {{ api_name }} logic here.",
+        "query": query,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+@mcp.tool()
+async def get_api_info(context: Context) -> Dict[str, Any]:
+    """
+    Get information about the {{ api_name }} API service.
+    
+    Args:
+        context: MCP context (injected automatically)
+    
+    Returns:
+        Dictionary containing API information and status
+    """
+    {% if requires_auth %}
+    # Check authentication status
+    api_key = get_session_api_key(context)
+    auth_status = "authenticated" if api_key else "not authenticated"
+    {% endif %}
+    
+    return {
+        "status": "ready",
+        {% if requires_auth %}"auth_status": auth_status,{% endif %}
+        "api_name": "{{ api_name }}",
+        "api_url": "{{ api_url }}",
+        "documentation": "{{ docs_url }}",
+        "description": "{{ api_description|capitalize }}",
+        {% if requires_auth %}"authentication": "Bearer token required in Authorization header"{% else %}"authentication": "No authentication required"{% endif %}
+    }
+
+
+def run_server():
+    """Entry point for the executable script"""
+    logger.info("Starting {{ api_name }} MCP server{{ auth_description }}...")
+    {% if requires_auth %}
+    logger.info("Authentication: Clients must provide Authorization: Bearer YOUR_API_KEY")
+    {% endif %}
+    
+    # Get configuration from environment
+    port = int(os.getenv("PORT", "8000"))
+    log_level = os.getenv("LOG_LEVEL", "INFO")
+    logger.info(f"Server will listen on port {port}")
+    
+    try:
+        mcp.run(
+            transport="streamable-http",
+            port=port,
+            host="0.0.0.0",
+            path="/mcp",
+            log_level=log_level.lower()
+        )
+    except Exception as e:
+        logger.error(f"Error starting MCP server: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    run_server()