MCP Protocol

Overview

Rogue supports the Model Context Protocol (MCP), which provides a flexible, tool-based interface for wrapping agents. MCP offers a simpler integration path by using a standard send_message tool interface, allowing you to wrap existing agents with minimal changes.

What is MCP?

The Model Context Protocol (MCP) is an open protocol that provides a standardized way for AI applications to interact with external tools and services. For Rogue integration, MCP uses a simple tool-based interface that abstracts away the complexity of your agent’s internal implementation. Key Features:

Simple Interface: Single send_message tool handles all communication
Minimal Wrapper: Wrap existing agents without major refactoring
Flexible Transport: Multiple transport options (SSE, STREAMABLE_HTTP)
Framework Agnostic: Works with any agent framework
Easy Testing: Simple interface makes testing straightforward

MCP Documentation

View the official Model Context Protocol documentation

Supported Transports

SSE (Server-Sent Events)

Server-Sent Events provide unidirectional, real-time event streaming from server to client. How it works:

Rogue establishes an SSE connection to your MCP server
Rogue invokes the send_message tool with a test message
Your agent processes the message and returns a response
The response streams back to Rogue via SSE
Rogue evaluates the response against test criteria

Configuration:

uvx rogue-ai cli \
  --evaluated-agent-url http://localhost:8080 \
  --protocol mcp \
  --transport sse

STREAMABLE_HTTP

HTTP-based streaming communication provides a simpler alternative to SSE while maintaining streaming capabilities. How it works:

Rogue makes HTTP POST requests to your MCP server
Requests invoke the send_message tool with test messages
Your agent streams responses back via chunked HTTP transfer
Rogue processes the streamed response
Connection closes after response completes

Configuration:

uvx rogue-ai cli \
  --evaluated-agent-url http://localhost:8080 \
  --protocol mcp \
  --transport streamable_http

The `send_message` Tool

The send_message tool is the core interface for MCP-based communication with Rogue. Tool Signature:

{
  name: "send_message",
  description: "Send a message to the agent and receive a response",
  parameters: {
    message: {
      type: "string",
      description: "The message to send to the agent"
    }
  },
  returns: {
    type: "string",
    description: "The agent's response"
  }
}

Input: A message string from Rogue Output: Your agent’s response string Example Implementation:

from mcp.server.fastmcp import Context, FastMCP


agent = get_agent()


mcp = FastMCP(
    "My Agent",
    host="127.0.0.1",
    port=10001,
)

@mcp.tool()
def send_message(message: str, context: Context) -> str:
    session_id: str | None = None
    try:
        request: Request = context.request_context.request  # type: ignore

        # The session id should be in the headers for streamable-http transport
        session_id = request.headers.get("mcp-session-id")

        # The session id might also be in query param when using sse transport
        if session_id is None:
            session_id = request.query_params.get("session_id")
    except Exception:
        session_id = None
        logger.exception("Error while extracting session id")

    if session_id is None:
        logger.error("Couldn't extract session id")

    # Invoking our agent
    response = agent.invoke(message, session_id)  # implement a func to communicate with your agent
    return response.get("content", "")


# When using "sse", the url will be http://localhost:10001/sse
# When using "streamable-http", the url will be http://localhost:10001/mcp
mcp.run(transport="sse") # transport="streamable-http"

Integration Steps

To integrate your agent with Rogue via MCP:

Build your agent using any framework of your choice
Create an MCP server wrapper for your agent
Implement the send_message tool that accepts a message parameter and returns a response
Choose your transport (SSE or STREAMABLE_HTTP)
Start your MCP server and make it accessible
Configure Rogue to connect to your MCP endpoint

Example Implementations

Rogue includes example MCP integrations demonstrating how to wrap agents:

MCP Examples

View MCP example implementations including LangGraph agent wrapper

The examples demonstrate:

Setting up an MCP server
Implementing the send_message tool
Wrapping a LangGraph agent with MCP
Configuring transports (SSE and STREAMABLE_HTTP)
Connecting Rogue to your MCP server

Getting Started

How It Works

Protocols & Transports

Configuration

Policy Evaluation

Red Teaming

Examples

Overview

What is MCP?

MCP Documentation

Supported Transports

SSE (Server-Sent Events)

STREAMABLE_HTTP

The `send_message` Tool

Integration Steps

Example Implementations

MCP Examples

​Overview

​What is MCP?

MCP Documentation

​Supported Transports

​SSE (Server-Sent Events)

​STREAMABLE_HTTP

​The send_message Tool

​Integration Steps

​Example Implementations

MCP Examples

Overview

What is MCP?

Supported Transports

SSE (Server-Sent Events)

STREAMABLE_HTTP

The `send_message` Tool

Integration Steps

Example Implementations