# Basic MCP server template
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import os

app = FastAPI(title="My MCP Server")

class MCPRequest(BaseModel):
    method: str
    params: dict

class MCPResponse(BaseModel):
    result: dict
    error: dict = None

@app.post("/mcp/invoke")
async def invoke(request: MCPRequest) -> MCPResponse:
    try:
        # Route to appropriate handler
        if request.method == "getBalance":
            result = await handle_get_balance(request.params)
        elif request.method == "executeAction":
            result = await handle_execute(request.params)
        else:
            raise HTTPException(404, f"Method {request.method} not found")

        return MCPResponse(result=result)
    except Exception as e:
        return MCPResponse(error={"message": str(e)})

async def handle_get_balance(params: dict):
    # Your implementation
    address = params.get("address")
    # Fetch balance logic
    return {"balance": "1000.0", "decimals": 18}

# MCP connection pooling
class MCPConnectionPool:
    def __init__(self, max_connections=10):
        self.pool = {}
        self.max_connections = max_connections

    async def get_connection(self, server_name: str):
        if server_name not in self.pool:
            self.pool[server_name] = await self.create_connection(server_name)
        return self.pool[server_name]

    async def create_connection(self, server_name: str):
        # Connection creation logic
        pass

# Caching MCP responses
from functools import lru_cache
import hashlib

@lru_cache(maxsize=1000)
async def cached_mcp_call(server: str, method: str, params_hash: str):
    # Cache frequently used MCP calls
    return await mcp.invoke(server, method, params)

def get_params_hash(params: dict) -> str:
    return hashlib.md5(str(params).encode()).hexdigest()