Module 4: Practical Implementation

​

Learning objectives

• Implement MCP solutions using official SDKs in C#, Java, TypeScript, JavaScript, and Python
• Debug and test MCP servers systematically
• Create and use server features — Resources, Prompts, and Tools
• Handle large result sets with cursor-based pagination
• Secure and deploy MCP servers to Azure

​

Official SDKs

​

Core server features

​

Language-specific implementations

​

Pagination and large result sets

​

Why pagination matters

• Memory exhaustion — loading millions of records at once
• Slow response times — users wait while all data loads
• Timeout errors — requests exceed time limits
• Poor AI performance — LLMs struggle with massive context windows

​

How cursor-based pagination works

​

Server-side pagination

from mcp.server import Server
from mcp.types import Tool, ListToolsResult

app = Server("paginated-server")

ALL_TOOLS = [
    Tool(name=f"tool_{i}", description=f"Tool number {i}", inputSchema={})
    for i in range(100)
]

PAGE_SIZE = 10

@app.list_tools()
async def list_tools(cursor: str | None = None) -> ListToolsResult:
    start_index = 0
    if cursor:
        try:
            start_index = int(cursor)
        except ValueError:
            start_index = 0

    end_index = min(start_index + PAGE_SIZE, len(ALL_TOOLS))
    page_tools = ALL_TOOLS[start_index:end_index]

    next_cursor = str(end_index) if end_index < len(ALL_TOOLS) else None

    return ListToolsResult(tools=page_tools, nextCursor=next_cursor)

​

Client-side pagination

from mcp import ClientSession

async def get_all_tools(session: ClientSession) -> list:
    """Fetch all tools using cursor-based pagination."""
    all_tools = []
    cursor = None

    while True:
        result = await session.list_tools(cursor=cursor)
        all_tools.extend(result.tools)

        if result.nextCursor is None:
            break
        cursor = result.nextCursor

    return all_tools

​

Cursor design strategies

cursor = "50"  # Start at item 50

cursor = "item_abc123"  # Start after this item

import base64, json

def encode_cursor(state: dict) -> str:
    return base64.b64encode(json.dumps(state).encode()).decode()

cursor = encode_cursor({"offset": 50, "filter": "active", "sort": "name"})

​

API management with Azure

• Rate limiting — prevent abuse and ensure fair usage
• Token management — centralized API key and OAuth handling
• Monitoring — request logging via Azure Monitor
• Load balancing — distribute traffic across server instances
• Security — authentication and authorization enforcement

​

Deploy a secured MCP server to Azure

git clone https://github.com/Azure-Samples/remote-mcp-apim-functions-python.git
cd remote-mcp-apim-functions-python

az provider register --namespace Microsoft.App --wait

azd up

npx @modelcontextprotocol/inspector

https://<apim-servicename>.azure-api.net/mcp/sse

​

Azure Functions quickstart templates

• Local development and debugging support
• Security by design with HTTPS and key-based auth
• OAuth support via built-in auth and APIM
• Network isolation with Azure Virtual Networks
• Simple one-command deployment: azd up

​

Key takeaways

• MCP SDKs provide language-specific tools for building robust solutions across C#, Java, TypeScript, JavaScript, and Python
• Use cursor-based pagination for all large result sets — never load everything into memory
• Debug and test your MCP servers systematically before deploying
• Azure API Management adds enterprise-grade security, rate limiting, and monitoring to remote MCP servers
• Reusable prompt templates ensure consistent AI interactions across your application

​

Exercise

1. Identify 3–4 tools useful for solving the problem
2. Create a workflow diagram showing how those tools interact
3. Implement a basic version of one tool using your preferred language
4. Add cursor-based pagination if the tool returns a list of items
5. Create a prompt template that helps the model use your tool effectively