Exposing an AI Agent as an MCP Server with MAF — Part 2: The HTTP/SSE Approach

Recap of Part 1#

In Part 1 we introduced MCP, explained what agent.as_mcp_server() does, and walked through the Stdio approach — where MCPStdioTool spawns the server as a subprocess and the two communicate over stdin/stdout. That approach is great for local tooling and IDE integrations.

But what if you need the server and client to run on different machines? Or you want a server that stays alive and serves multiple clients concurrently? Or you need to deploy the agent as part of a microservices architecture? The Stdio approach cannot do any of those things. That is where HTTP/SSE comes in.

What is HTTP/SSE Transport?#

Server-Sent Events (SSE) is a standard web technology where a client opens a persistent HTTP connection and the server pushes events to it over time. For MCP, this gives us a proper client/server architecture — the server is a real HTTP service with its own port, clients connect over the network using a URL, the server can handle many clients concurrently, and client and server have completely independent lifecycles.

The MCP protocol over SSE uses two HTTP routes. GET /sse is where the client opens a persistent connection to receive events. POST /messages is where the client sends requests such as tool calls.

HTTP/SSE is the right choice for production and staging deployments, for scenarios where client and server run on different machines or in different containers, for any situation where multiple clients need to share one server, and for microservice architectures where agents are deployed and scaled independently.

The Server#

The server is a standalone HTTP application built with Starlette and served by uvicorn. The agent.as_mcp_server() call is identical to Part 1 — only the transport layer changes.

1
"""
2
server.py — ServiceNow Agent as MCP Server (HTTP/SSE)
3
=======================================================
4
A standalone MCP server over HTTP/SSE. Run this independently
5
in its own terminal before starting the client.
6

7
Run:
8
    python server.py
9

10
Available at:
11
    http://localhost:8080/sse
12
"""
13

14
import os
15
import uvicorn
16
from dotenv import load_dotenv
17
from mcp.server.sse import SseServerTransport
18
from starlette.applications import Starlette
19
from starlette.routing import Route
20
from agent_framework import ChatAgent
21
from agent_framework.openai import OpenAIChatClient
22
from openai import AsyncAzureOpenAI
23
from tools import create_incident, update_incident, search_incident
24

25
load_dotenv()
26

27
MCP_PORT = 8080
28

29

30
def make_client() -> OpenAIChatClient:
31
    return OpenAIChatClient(
32
        model_id=os.environ.get("AZURE_OPENAI_DEPLOYMENT_NAME", "gpt-4o"),
33
        async_client=AsyncAzureOpenAI(
34
            azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
35
            api_key=os.environ["AZURE_OPENAI_API_KEY"],
36
            api_version="2024-12-01-preview",
37
        ),
38
    )
39

40

41
# Build the agent
42
agent = ChatAgent(
43
    chat_client=make_client(),
44
    name="ServiceNowAgent",
45
    description="Manages ServiceNow incidents — create, update, search.",
46
    instructions="You are a ServiceNow assistant. Use your tools to manage incidents.",
47
    tools=[create_incident, update_incident, search_incident],
48
)
49

50
# One line — identical to Part 1
51
mcp_server = agent.as_mcp_server()
52

53
# Wire up the HTTP/SSE transport
54
sse = SseServerTransport("/messages")
55

56

57
async def handle_sse(request):
58
    """Client opens a persistent SSE connection here to receive events."""
59
    async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
60
        await mcp_server.run(
61
            streams[0],
62
            streams[1],
63
            mcp_server.create_initialization_options(),
64
        )
65

66

67
async def handle_messages(request):
68
    """Client sends tool call requests here via POST."""
69
    await sse.handle_post_message(request.scope, request.receive, request._send)
70

71

72
app = Starlette(routes=[
73
    Route("/sse",      handle_sse,      methods=["GET"]),
74
    Route("/messages", handle_messages, methods=["POST"]),
75
])
76

77

78
if __name__ == "__main__":
79
    print(f"ServiceNow MCP server → http://localhost:{MCP_PORT}/sse")
80
    uvicorn.run(app, host="0.0.0.0", port=MCP_PORT)

The agent.as_mcp_server() call is exactly the same as in Part 1. The only difference is that instead of wiring it to stdio streams, we wire it to an SseServerTransport backed by a Starlette HTTP application.

The GET /sse route upgrades the incoming connection to a persistent SSE stream. The MCP server runs the full session over this stream, pushing tool definitions and responses back to the client as events. The POST /messages route receives tool call requests from the client and SseServerTransport routes them to the correct active session internally.

The Client#

The client connects to the running server over HTTP using MCPStreamableHTTPTool. Critically, it does not spawn the server — it simply connects to the URL. The server must already be running independently before the client starts.

1
"""
2
client.py — ServiceNow MCP Client (HTTP/SSE)
3
=============================================
4
Connects to the independently running server.py over HTTP/SSE.
5

6
Start the server first:
7
    python server.py
8

9
Then run the client:
10
    python client.py
11
"""
12

13
import asyncio
14
import os
15
from dotenv import load_dotenv
16
from openai import AsyncAzureOpenAI
17
from agent_framework import ChatAgent, MCPStreamableHTTPTool
18
from agent_framework.openai import OpenAIChatClient
19

20
load_dotenv()
21

22
MCP_SERVER_URL = "http://localhost:8080/sse"
23

24

25
def make_client() -> OpenAIChatClient:
26
    return OpenAIChatClient(
27
        model_id=os.environ.get("AZURE_OPENAI_DEPLOYMENT_NAME", "gpt-4o"),
28
        async_client=AsyncAzureOpenAI(
29
            azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
30
            api_key=os.environ["AZURE_OPENAI_API_KEY"],
31
            api_version="2024-12-01-preview",
32
        ),
33
    )
34

35

36
async def main():
37
    questions = [
38
        "Create a high urgency incident for a login failure affecting all users.",
39
        "Search for any VPN related incidents.",
40
        "Update incident INC0012346 to Resolved with note 'VPN config fixed'.",
41
    ]
42

43
    async with (
44
        MCPStreamableHTTPTool(
45
            name="ServiceNowAgent",
46
            url=MCP_SERVER_URL,
47
        ) as servicenow_mcp,
48
        ChatAgent(
49
            chat_client=make_client(),
50
            name="Client",
51
            instructions="Use the ServiceNow agent tool to handle requests.",
52
            tools=servicenow_mcp,
53
        ) as agent,
54
    ):
55
        for question in questions:
56
            print(f"Q: {question}")
57
            result = await agent.run(question)
58
            print(f"A: {result}\n")
59

60

61
if __name__ == "__main__":
62
    asyncio.run(main())

The switch from MCPStdioTool to MCPStreamableHTTPTool is the only meaningful change in the client. The table below captures the difference:

	`MCPStdioTool`	`MCPStreamableHTTPTool`
Spawns server?	Yes — as a subprocess	No — connects to existing server
Transport	stdin/stdout	HTTP/SSE
Server location	Same machine only	Any reachable URL
Server lifecycle	Tied to client	Fully independent
Config	`command` + `args`	`url`

Running the HTTP/SSE Approach#

Unlike Part 1 where you run a single command, here you run two in separate terminals.

Terminal 1 — Start the server:

1
python server.py

1
ServiceNow MCP server → http://localhost:8080/sse
2
INFO:     Uvicorn running on http://0.0.0.0:8080
3
INFO:     Application startup complete.

Leave this terminal open. The server is now waiting for connections.

Terminal 2 — Run the client:

1
python client.py

1
Q: Create a high urgency incident for a login failure affecting all users.
2
A: Incident INC0012345 has been created with High urgency and status New.
3

4
Q: Search for any VPN related incidents.
5
A: Found INC0012346 — VPN not working — In Progress — Medium urgency.
6

7
Q: Update incident INC0012346 to Resolved with note 'VPN config fixed'.
8
A: Incident INC0012346 updated to Resolved. Notes: VPN config fixed.

The full flow across both processes looks like this:

1
Terminal 1: python server.py
2
    │
3
    └── Starlette HTTP app starts on port 8080
4
            │
5
            └── mcp_server waits for SSE connections at /sse
6

7
Terminal 2: python client.py
8
    │
9
    └── MCPStreamableHTTPTool connects to http://localhost:8080/sse
10
            │
11
            └── client ChatAgent receives question
12
                    │
13
                    └── sends tool call via HTTP POST to /messages
14
                            │
15
                            └── server ChatAgent reasons and calls tools
16
                                    │
17
                                    └── result pushed back via SSE → printed

Adding Authentication#

In production you will want to secure the server. MCPStreamableHTTPTool accepts custom headers, making Bearer token authentication straightforward to add:

1
# server.py — validate the token before accepting the SSE connection
2
async def handle_sse(request):
3
    token = request.headers.get("Authorization", "")
4
    if token != f"Bearer {os.environ['MCP_SECRET_TOKEN']}":
5
        from starlette.responses import Response
6
        return Response("Unauthorized", status_code=401)
7
    async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
8
        await mcp_server.run(streams[0], streams[1], mcp_server.create_initialization_options())
9

10
# client.py — pass the token in request headers
11
async with MCPStreamableHTTPTool(
12
    name="ServiceNowAgent",
13
    url=MCP_SERVER_URL,
14
    headers={"Authorization": f"Bearer {os.environ['MCP_SECRET_TOKEN']}"},
15
) as servicenow_mcp:
16
    ...

Deploying to the Cloud#

Because the server is a standard HTTP application served by uvicorn, it deploys anywhere that runs Python. A minimal Dockerfile:

1
FROM python:3.12-slim
2
WORKDIR /app
3
COPY requirements.txt .
4
RUN pip install -r requirements.txt
5
COPY . .
6
EXPOSE 8080
7
CMD ["python", "server.py"]

This works without modification on Azure Container Apps, AWS ECS, and Google Cloud Run. Once deployed, update the client to point at the remote URL:

1
MCP_SERVER_URL = "https://servicenow-agent.yourcompany.com/sse"

Stdio vs HTTP/SSE: The Full Comparison#

	Stdio (Part 1)	HTTP/SSE (Part 2)
How to run	`python client.py` only	`python server.py` then `python client.py`
Transport	stdin/stdout	HTTP over the network
Server spawned by	`MCPStdioTool` automatically	You, independently
MAF tool class	`MCPStdioTool`	`MCPStreamableHTTPTool`
Multiple clients	No	Yes
Remote server	No	Yes
Authentication	Not applicable	Headers / Bearer tokens
Best for	Local dev, IDE plugins	Production, microservices
`as_mcp_server()` call	Identical	Identical

The last row is the most important one. agent.as_mcp_server() is exactly the same in both approaches. The only thing that changes is how you wire the transport. MAF decouples the agent completely from the delivery mechanism.

What’s Next#

Part 3 asks a deeper question: how is agent.as_mcp_server() different from just implementing an MCP server directly with the official Python MCP SDK? The answer is more significant than just reduced boilerplate — it is a fundamental architectural difference in where the intelligence lives.

➡️ Continue to Part 3: MAF vs Raw MCP